annotate Implab.Test/AsyncTests.cs @ 209:a867536c68fc v2

Bound promise to CancellationToken Added new states to ExecutionSate enum. Added Safe.Guard() method to handle cleanup of the result of the promise
author cin
date Wed, 16 Nov 2016 03:06:08 +0300
parents 8200ab154c8a
children d6fe09f5592c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
1 using System;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
2 using System.Reflection;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
3 using System.Threading;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
4 using Implab.Parallels;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
5
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
6 #if MONO
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
7
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
8 using NUnit.Framework;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
9 using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
145
706fccb85524 RC: cancellation support for promises + tests
cin
parents: 138
diff changeset
10 using TestMethodAttribute = NUnit.Framework.TestAttribute;
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
11
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
12 #else
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
13
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
14 using Microsoft.VisualStudio.TestTools.UnitTesting;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
15
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
16 #endif
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
17
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
18 namespace Implab.Test {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
19 [TestClass]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
20 public class AsyncTests {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
21 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
22 public void ResolveTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
23 int res = -1;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
24 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
25 p.Then(x => res = x);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
26 p.Resolve(100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
27
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
28 Assert.AreEqual(100, res);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
29 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
30
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
31 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
32 public void RejectTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
33 int res = -1;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
34 Exception err = null;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
35
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
36 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
37 p.Then(
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
38 x => res = x,
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
39 e => {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
40 err = e;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
41 return -2;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
42 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
43 );
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
44 p.Reject(new ApplicationException("error"));
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
45
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
46 Assert.AreEqual(res, -1);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
47 Assert.AreEqual(err.Message, "error");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
48
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
49 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
50
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
51 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
52 public void CancelExceptionTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
53 var p = new Promise<bool>();
145
706fccb85524 RC: cancellation support for promises + tests
cin
parents: 138
diff changeset
54 p.CancelOperation(null);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
55
138
f75cfa58e3d4 added ICancellable.Cancel(Exception) to allow specify the reason of cancellation
cin
parents: 136
diff changeset
56 var p2 = p.Then(x => x, null, reason => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
57 throw new ApplicationException("CANCELLED");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
58 });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
59
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
60 try {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
61 p2.Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
62 Assert.Fail();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
63 } catch (ApplicationException err) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
64 Assert.AreEqual("CANCELLED", err.InnerException.Message);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
65 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
66
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
67 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
68
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
69 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
70 public void ContinueOnCancelTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
71 var p = new Promise<bool>();
145
706fccb85524 RC: cancellation support for promises + tests
cin
parents: 138
diff changeset
72 p.CancelOperation(null);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
73
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
74 var p2 = p
145
706fccb85524 RC: cancellation support for promises + tests
cin
parents: 138
diff changeset
75 .Then(x => x, null, reason => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
76 throw new ApplicationException("CANCELLED");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
77 })
138
f75cfa58e3d4 added ICancellable.Cancel(Exception) to allow specify the reason of cancellation
cin
parents: 136
diff changeset
78 .Then(x => x, e => true);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
79
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
80 Assert.AreEqual(true, p2.Join());
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
81 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
82
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
83 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
84 public void JoinSuccessTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
85 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
86 p.Resolve(100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
87 Assert.AreEqual(p.Join(), 100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
88 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
89
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
90 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
91 public void JoinFailTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
92 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
93 p.Reject(new ApplicationException("failed"));
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
94
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
95 try {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
96 p.Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
97 throw new ApplicationException("WRONG!");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
98 } catch (TargetInvocationException err) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
99 Assert.AreEqual(err.InnerException.Message, "failed");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
100 } catch {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
101 Assert.Fail("Got wrong excaption");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
102 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
103 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
104
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
105 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
106 public void MapTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
107 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
108
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
109 var p2 = p.Then(x => x.ToString());
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
110 p.Resolve(100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
111
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
112 Assert.AreEqual(p2.Join(), "100");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
113 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
114
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
115 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
116 public void FixErrorTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
117 var p = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
118
138
f75cfa58e3d4 added ICancellable.Cancel(Exception) to allow specify the reason of cancellation
cin
parents: 136
diff changeset
119 var p2 = p.Then(x => x, e => 101);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
120
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
121 p.Reject(new Exception());
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
122
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
123 Assert.AreEqual(p2.Join(), 101);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
124 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
125
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
126 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
127 public void ChainTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
128 var p1 = new Promise<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
129
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
130 var p3 = p1.Chain(x => {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
131 var p2 = new Promise<string>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
132 p2.Resolve(x.ToString());
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
133 return p2;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
134 });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
135
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
136 p1.Resolve(100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
137
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
138 Assert.AreEqual(p3.Join(), "100");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
139 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
140
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
141 [TestMethod]
105
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
142 public void ChainFailTest() {
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
143 var p1 = new Promise<int>();
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
144
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
145 var p3 = p1.Chain(x => {
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
146 var p2 = new Promise<string>();
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
147 p2.Reject(new Exception("DIE!!!"));
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
148 return p2;
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
149 });
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
150
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
151 p1.Resolve(100);
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
152
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
153 Assert.IsTrue(p3.IsResolved);
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
154 }
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
155
4d308952fd5e minor fixes
cin
parents: 81
diff changeset
156 [TestMethod]
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
157 public void PoolTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
158 var pid = Thread.CurrentThread.ManagedThreadId;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
159 var p = AsyncPool.Invoke(() => Thread.CurrentThread.ManagedThreadId);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
160
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
161 Assert.AreNotEqual(pid, p.Join());
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
162 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
163
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
164 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
165 public void WorkerPoolSizeTest() {
81
2c5631b43c7d dispatch pool rewritten
cin
parents: 80
diff changeset
166 var pool = new WorkerPool(5, 10, 1);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
167
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
168 Assert.AreEqual(5, pool.PoolSize);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
169
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
170 pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
171 pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
172 pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
173
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
174 Assert.AreEqual(5, pool.PoolSize);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
175
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
176 for (int i = 0; i < 100; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
177 pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
178 Thread.Sleep(200);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
179 Assert.AreEqual(10, pool.PoolSize);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
180
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
181 pool.Dispose();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
182 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
183
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
184 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
185 public void WorkerPoolCorrectTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
186 var pool = new WorkerPool(0,1000,100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
187
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
188 const int iterations = 1000;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
189 int pending = iterations;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
190 var stop = new ManualResetEvent(false);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
191
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
192 var count = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
193 for (int i = 0; i < iterations; i++) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
194 pool
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
195 .Invoke(() => 1)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
196 .Then(x => Interlocked.Add(ref count, x))
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
197 .Then(x => Math.Log10(x))
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
198 .On(() => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
199 Interlocked.Decrement(ref pending);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
200 if (pending == 0)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
201 stop.Set();
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
202 }, PromiseEventType.All);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
203 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
204
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
205 stop.WaitOne();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
206
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
207 Assert.AreEqual(iterations, count);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
208 Console.WriteLine("Max threads: {0}", pool.MaxRunningThreads);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
209 pool.Dispose();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
210
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
211 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
212
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
213 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
214 public void WorkerPoolDisposeTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
215 var pool = new WorkerPool(5, 20);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
216 Assert.AreEqual(5, pool.PoolSize);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
217 pool.Dispose();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
218 Thread.Sleep(500);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
219 Assert.AreEqual(0, pool.PoolSize);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
220 pool.Dispose();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
221 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
222
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
223 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
224 public void MTQueueTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
225 var queue = new MTQueue<int>();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
226 int res;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
227
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
228 queue.Enqueue(10);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
229 Assert.IsTrue(queue.TryDequeue(out res));
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
230 Assert.AreEqual(10, res);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
231 Assert.IsFalse(queue.TryDequeue(out res));
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
232
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
233 for (int i = 0; i < 1000; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
234 queue.Enqueue(i);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
235
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
236 for (int i = 0; i < 1000; i++) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
237 queue.TryDequeue(out res);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
238 Assert.AreEqual(i, res);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
239 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
240
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
241 int writers = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
242 int readers = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
243 var stop = new ManualResetEvent(false);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
244 int total = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
245
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
246 const int itemsPerWriter = 10000;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
247 const int writersCount = 10;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
248
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
249 for (int i = 0; i < writersCount; i++) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
250 Interlocked.Increment(ref writers);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
251 AsyncPool
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
252 .RunThread(() => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
253 for (int ii = 0; ii < itemsPerWriter; ii++) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
254 queue.Enqueue(1);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
255 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
256 return 1;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
257 })
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
258 .On(() => Interlocked.Decrement(ref writers), PromiseEventType.All);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
259 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
260
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
261 for (int i = 0; i < 10; i++) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
262 Interlocked.Increment(ref readers);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
263 AsyncPool
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
264 .RunThread(() => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
265 int t;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
266 do {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
267 while (queue.TryDequeue(out t))
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
268 Interlocked.Add(ref total, t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
269 } while (writers > 0);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
270 return 1;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
271 })
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
272 .On(() => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
273 Interlocked.Decrement(ref readers);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
274 if (readers == 0)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
275 stop.Set();
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
276 }, PromiseEventType.All);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
277 }
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
278
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
279 stop.WaitOne();
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
280
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
281 Assert.AreEqual(100000, total);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
282 }
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
283
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
284 [TestMethod]
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
285 public void AsyncQueueTest() {
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
286 var queue = new AsyncQueue<int>();
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
287 int res;
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
288
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
289 queue.Enqueue(10);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
290 Assert.IsTrue(queue.TryDequeue(out res));
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
291 Assert.AreEqual(10, res);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
292 Assert.IsFalse(queue.TryDequeue(out res));
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
293
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
294 for (int i = 0; i < 1000; i++)
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
295 queue.Enqueue(i);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
296
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
297 for (int i = 0; i < 1000; i++) {
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
298 queue.TryDequeue(out res);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
299 Assert.AreEqual(i, res);
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
300 }
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
301
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
302 const int count = 10000000;
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
303
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
304 int res1 = 0, res2 = 0;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
305 var t1 = Environment.TickCount;
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
306
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
307 AsyncPool.RunThread(
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
308 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
309 for (var i = 0; i < count; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
310 queue.Enqueue(1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
311 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
312 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
313 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
314 for (var i = 0; i < count; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
315 queue.Enqueue(2);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
316 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
317 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
318 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
319 int temp;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
320 int i = 0;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
321 while (i < count)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
322 if (queue.TryDequeue(out temp)) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
323 i++;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
324 res1 += temp;
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
325 }
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
326 Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
327 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
328 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
329 int temp;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
330 int i = 0;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
331 while (i < count)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
332 if (queue.TryDequeue(out temp)) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
333 i++;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
334 res2 += temp;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
335 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
336 Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
337 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
338 )
205
8200ab154c8a Added ResetState to RunnableComponent to reset in case of failure
cin
parents: 151
diff changeset
339 .PromiseAll()
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
340 .Join();
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
341
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
342 Assert.AreEqual(count * 3, res1 + res2);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
343
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
344 Console.WriteLine(
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
345 "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
346 Environment.TickCount - t1,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
347 res1,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
348 res2,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
349 res1 + res2,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
350 count
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
351 );
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
352 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
353
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
354 [TestMethod]
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
355 public void AsyncQueueBatchTest() {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
356 var queue = new AsyncQueue<int>();
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
357
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
358 const int wBatch = 29;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
359 const int wCount = 400000;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
360 const int total = wBatch * wCount * 2;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
361 const int summ = wBatch * wCount * 3;
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
362
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
363 int r1 = 0, r2 = 0;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
364 const int rBatch = 111;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
365 int read = 0;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
366
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
367 var t1 = Environment.TickCount;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
368
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
369 AsyncPool.RunThread(
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
370 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
371 var buffer = new int[wBatch];
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
372 for(int i = 0; i<wBatch; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
373 buffer[i] = 1;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
374
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
375 for(int i =0; i < wCount; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
376 queue.EnqueueRange(buffer,0,wBatch);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
377 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
378 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
379 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
380 var buffer = new int[wBatch];
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
381 for(int i = 0; i<wBatch; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
382 buffer[i] = 2;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
383
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
384 for(int i =0; i < wCount; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
385 queue.EnqueueRange(buffer,0,wBatch);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
386 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
387 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
388 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
389 var buffer = new int[rBatch];
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
390
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
391 while(read < total) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
392 int actual;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
393 if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
394 for(int i=0; i< actual; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
395 r1 += buffer[i];
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
396 Interlocked.Add(ref read, actual);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
397 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
398 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
399
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
400 Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
401 },
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
402 () => {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
403 var buffer = new int[rBatch];
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
404
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
405 while(read < total) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
406 int actual;
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
407 if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
408 for(int i=0; i< actual; i++)
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
409 r2 += buffer[i];
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
410 Interlocked.Add(ref read, actual);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
411 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
412 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
413
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
414 Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
415 }
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
416 )
205
8200ab154c8a Added ResetState to RunnableComponent to reset in case of failure
cin
parents: 151
diff changeset
417 .PromiseAll()
121
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
418 .Join();
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
419
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
420 Assert.AreEqual(summ , r1 + r2);
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
421
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
422 Console.WriteLine(
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
423 "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
424 Environment.TickCount - t1,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
425 r1,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
426 r2,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
427 r1 + r2,
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
428 total
62d2f1e98c4e working version of AsyncQueue and batch operations
cin
parents: 119
diff changeset
429 );
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
430 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
431
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
432 [TestMethod]
122
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
433 public void AsyncQueueChunkDequeueTest() {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
434 var queue = new AsyncQueue<int>();
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
435
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
436 const int wBatch = 31;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
437 const int wCount = 200000;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
438 const int total = wBatch * wCount * 3;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
439 const int summ = wBatch * wCount * 6;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
440
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
441 int r1 = 0, r2 = 0;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
442 const int rBatch = 1024;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
443 int read = 0;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
444
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
445 var t1 = Environment.TickCount;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
446
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
447 AsyncPool.RunThread(
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
448 () => {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
449 var buffer = new int[wBatch];
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
450 for(int i = 0; i<wBatch; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
451 buffer[i] = 1;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
452
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
453 for(int i =0; i < wCount; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
454 queue.EnqueueRange(buffer,0,wBatch);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
455 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
456 },
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
457 () => {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
458 var buffer = new int[wBatch];
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
459 for(int i = 0; i<wBatch; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
460 buffer[i] = 2;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
461
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
462 for(int i =0; i < wCount; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
463 queue.EnqueueRange(buffer,0,wBatch);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
464 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
465 },
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
466 () => {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
467 var buffer = new int[wBatch];
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
468 for(int i = 0; i<wBatch; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
469 buffer[i] = 3;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
470
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
471 for(int i =0; i < wCount; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
472 queue.EnqueueRange(buffer,0,wBatch);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
473 Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
474 },
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
475 () => {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
476 var buffer = new int[rBatch];
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
477 int count = 1;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
478 double avgchunk = 0;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
479 while(read < total) {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
480 int actual;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
481 if (queue.TryDequeueChunk(buffer,0,rBatch,out actual)) {
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
482 for(int i=0; i< actual; i++)
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
483 r2 += buffer[i];
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
484 Interlocked.Add(ref read, actual);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
485 avgchunk = avgchunk*(count-1)/count + actual/(double)count;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
486 count ++;
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
487 }
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
488 }
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
489
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
490 Console.WriteLine("done reader #2: {0} ms, avg chunk size: {1}", Environment.TickCount - t1, avgchunk);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
491 }
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
492 )
205
8200ab154c8a Added ResetState to RunnableComponent to reset in case of failure
cin
parents: 151
diff changeset
493 .PromiseAll()
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
494 .Join();
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
495
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
496 Assert.AreEqual(summ , r1 + r2);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
497
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
498 Console.WriteLine(
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
499 "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
500 Environment.TickCount - t1,
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
501 r1,
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
502 r2,
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
503 r1 + r2,
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
504 total
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
505 );
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
506 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
507
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
508 [TestMethod]
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
509 public void AsyncQueueDrainTest() {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
510 var queue = new AsyncQueue<int>();
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
511
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
512 const int wBatch = 11;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
513 const int wCount = 200000;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
514 const int total = wBatch * wCount * 3;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
515 const int summ = wBatch * wCount * 3;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
516
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
517 int r1 = 0, r2 = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
518 const int rBatch = 11;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
519 int read = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
520
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
521 var t1 = Environment.TickCount;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
522
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
523 AsyncPool.RunThread(
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
524 () => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
525 var buffer = new int[wBatch];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
526 for(int i = 0; i<wBatch; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
527 buffer[i] = 1;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
528
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
529 for(int i =0; i < wCount; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
530 queue.EnqueueRange(buffer,0,wBatch);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
531 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
532 },
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
533 () => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
534 for(int i =0; i < wCount * wBatch; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
535 queue.Enqueue(1);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
536 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
537 },
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
538 () => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
539 var buffer = new int[wBatch];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
540 for(int i = 0; i<wBatch; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
541 buffer[i] = 1;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
542
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
543 for(int i =0; i < wCount; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
544 queue.EnqueueRange(buffer,0,wBatch);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
545 Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
546 },
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
547 /*() => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
548 int temp;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
549 int count = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
550 while (read < total)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
551 if (queue.TryDequeue(out temp)) {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
552 count++;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
553 r1 += temp;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
554 Interlocked.Increment(ref read);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
555 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
556 Console.WriteLine("done reader #1: {0} ms, {1} count", Environment.TickCount - t1, count);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
557 },*/
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
558 /*() => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
559 var buffer = new int[rBatch];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
560 var count = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
561 while(read < total) {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
562 int actual;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
563 if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
564 for(int i=0; i< actual; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
565 r1 += buffer[i];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
566 Interlocked.Add(ref read, actual);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
567 count += actual;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
568 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
569 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
570
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
571 Console.WriteLine("done reader #1: {0} ms, {1} items", Environment.TickCount - t1, count);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
572 },*/
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
573 () => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
574 var count = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
575 while(read < total) {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
576 var buffer = queue.Drain();
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
577 for(int i=0; i< buffer.Length; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
578 r1 += buffer[i];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
579 Interlocked.Add(ref read, buffer.Length);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
580 count += buffer.Length;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
581 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
582 Console.WriteLine("done reader #1: {0} ms, {1} items", Environment.TickCount - t1, count);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
583 },
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
584 () => {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
585 var count = 0;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
586 while(read < total) {
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
587 var buffer = queue.Drain();
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
588 for(int i=0; i< buffer.Length; i++)
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
589 r2 += buffer[i];
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
590 Interlocked.Add(ref read, buffer.Length);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
591 count += buffer.Length;
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
592 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
593 Console.WriteLine("done reader #2: {0} ms, {1} items", Environment.TickCount - t1, count);
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
594 }
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
595 )
205
8200ab154c8a Added ResetState to RunnableComponent to reset in case of failure
cin
parents: 151
diff changeset
596 .PromiseAll()
122
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
597 .Join();
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
598
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
599 Assert.AreEqual(summ , r1 + r2);
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
600
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
601 Console.WriteLine(
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
602 "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
603 Environment.TickCount - t1,
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
604 r1,
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
605 r2,
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
606 r1 + r2,
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
607 total
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
608 );
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
609 }
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
610
0c8685c8b56b minor fixes and improvements of AsyncQueue, additional tests
cin
parents: 121
diff changeset
611 [TestMethod]
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
612 public void ParallelMapTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
613
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
614 const int count = 100000;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
615
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
616 var args = new double[count];
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
617 var rand = new Random();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
618
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
619 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
620 args[i] = rand.NextDouble();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
621
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
622 var t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
623 var res = args.ParallelMap(x => Math.Sin(x*x), 4).Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
624
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
625 Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
626
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
627 t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
628 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
629 Assert.AreEqual(Math.Sin(args[i] * args[i]), res[i]);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
630 Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
631 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
632
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
633 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
634 public void ChainedMapTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
635
125
f803565868a4 improved performance of promises
cin
parents: 124
diff changeset
636 using (var pool = new WorkerPool()) {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
637 const int count = 10000;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
638
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
639 var args = new double[count];
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
640 var rand = new Random();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
641
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
642 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
643 args[i] = rand.NextDouble();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
644
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
645 var t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
646 var res = args
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
647 .ChainedMap(
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
648 // Analysis disable once AccessToDisposedClosure
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
649 x => pool.Invoke(
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
650 () => Math.Sin(x * x)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
651 ),
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
652 4
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
653 )
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
654 .Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
655
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
656 Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
657
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
658 t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
659 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
660 Assert.AreEqual(Math.Sin(args[i] * args[i]), res[i]);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
661 Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
662 Console.WriteLine("Max workers: {0}", pool.MaxRunningThreads);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
663 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
664 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
665
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
666 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
667 public void ParallelForEachTest() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
668
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
669 const int count = 100000;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
670
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
671 var args = new int[count];
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
672 var rand = new Random();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
673
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
674 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
675 args[i] = (int)(rand.NextDouble() * 100);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
676
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
677 int result = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
678
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
679 var t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
680 args.ParallelForEach(x => Interlocked.Add(ref result, x), 4).Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
681
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
682 Console.WriteLine("Iteration complete in {0} ms, result: {1}", Environment.TickCount - t, result);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
683
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
684 int result2 = 0;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
685
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
686 t = Environment.TickCount;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
687 for (int i = 0; i < count; i++)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
688 result2 += args[i];
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
689 Assert.AreEqual(result2, result);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
690 Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
691 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
692
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
693 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
694 public void ComplexCase1Test() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
695 var flags = new bool[3];
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
696
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
697 // op1 (aync 200ms) => op2 (async 200ms) => op3 (sync map)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
698
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
699 var step1 = PromiseHelper
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
700 .Sleep(200, "Alan")
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
701 .On(() => flags[0] = true, PromiseEventType.Cancelled);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
702 var p = step1
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
703 .Chain(x =>
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
704 PromiseHelper
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
705 .Sleep(200, "Hi, " + x)
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
706 .Then(y => y)
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
707 .On(() => flags[1] = true, PromiseEventType.Cancelled)
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
708 )
119
2573b562e328 Promises rewritten, added improved version of AsyncQueue
cin
parents: 106
diff changeset
709 .On(() => flags[2] = true, PromiseEventType.Cancelled);
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
710 step1.Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
711 p.Cancel();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
712 try {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
713 Assert.AreEqual(p.Join(), "Hi, Alan");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
714 Assert.Fail("Shouldn't get here");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
715 } catch (OperationCanceledException) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
716 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
717
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
718 Assert.IsFalse(flags[0]);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
719 Assert.IsTrue(flags[1]);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
720 Assert.IsTrue(flags[2]);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
721 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
722
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
723 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
724 public void ChainedCancel1Test() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
725 // при отмене сцепленной асинхронной операции все обещание должно
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
726 // завершаться ошибкой OperationCanceledException
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
727 var p = PromiseHelper
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
728 .Sleep(1, "Hi, HAL!")
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
729 .Then(x => {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
730 // запускаем две асинхронные операции
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
731 var result = PromiseHelper.Sleep(1000, "HEM ENABLED!!!");
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
732 // вторая операция отменяет первую до завершения
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
733 PromiseHelper
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
734 .Sleep(100, "HAL, STOP!")
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
735 .Then(result.Cancel);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
736 return result;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
737 });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
738 try {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
739 p.Join();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
740 } catch (TargetInvocationException err) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
741 Assert.IsTrue(err.InnerException is OperationCanceledException);
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
742 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
743 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
744
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
745 [TestMethod]
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
746 public void ChainedCancel2Test() {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
747 // при отмене цепочки обещаний, вложенные операции также должны отменяться
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
748 var pSurvive = new Promise<bool>();
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
749 var hemStarted = new Signal();
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
750 var p = PromiseHelper
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
751 .Sleep(1, "Hi, HAL!")
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
752 .Chain(() => {
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
753 hemStarted.Set();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
754 // запускаем две асинхронные операции
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
755 var result = PromiseHelper
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
756 .Sleep(2000, "HEM ENABLED!!!")
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
757 .Then(() => pSurvive.Resolve(false));
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
758
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
759 result
138
f75cfa58e3d4 added ICancellable.Cancel(Exception) to allow specify the reason of cancellation
cin
parents: 136
diff changeset
760 .On(() => pSurvive.Resolve(true), PromiseEventType.Cancelled);
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
761
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
762 return result;
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
763 });
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
764
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
765 hemStarted.Wait();
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
766 p.Cancel();
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
767
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
768 try {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
769 p.Join();
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
770 Assert.Fail();
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
771 } catch (OperationCanceledException) {
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
772 }
149
eb793fbbe4ea fixed promises cancellation
cin
parents: 145
diff changeset
773 Assert.IsTrue(pSurvive.Join());
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
774 }
136
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
775
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
776 [TestMethod]
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
777 public void SharedLockTest() {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
778 var l = new SharedLock();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
779 int shared = 0;
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
780 int exclusive = 0;
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
781 var s1 = new Signal();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
782 var log = new AsyncQueue<string>();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
783
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
784 try {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
785 AsyncPool.RunThread(
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
786 () => {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
787 log.Enqueue("Reader #1 started");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
788 try {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
789 l.LockShared();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
790 log.Enqueue("Reader #1 lock got");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
791 if (Interlocked.Increment(ref shared) == 2)
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
792 s1.Set();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
793 s1.Wait();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
794 log.Enqueue("Reader #1 finished");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
795 Interlocked.Decrement(ref shared);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
796 } finally {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
797 l.Release();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
798 log.Enqueue("Reader #1 lock released");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
799 }
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
800 },
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
801 () => {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
802 log.Enqueue("Reader #2 started");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
803
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
804 try {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
805 l.LockShared();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
806 log.Enqueue("Reader #2 lock got");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
807
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
808 if (Interlocked.Increment(ref shared) == 2)
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
809 s1.Set();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
810 s1.Wait();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
811 log.Enqueue("Reader #2 upgrading to writer");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
812 Interlocked.Decrement(ref shared);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
813 l.Upgrade();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
814 log.Enqueue("Reader #2 upgraded");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
815
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
816 Assert.AreEqual(1, Interlocked.Increment(ref exclusive));
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
817 Assert.AreEqual(0, shared);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
818 log.Enqueue("Reader #2 finished");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
819 Interlocked.Decrement(ref exclusive);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
820 } finally {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
821 l.Release();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
822 log.Enqueue("Reader #2 lock released");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
823 }
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
824 },
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
825 () => {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
826 log.Enqueue("Writer #1 started");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
827 try {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
828 l.LockExclusive();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
829 log.Enqueue("Writer #1 got the lock");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
830 Assert.AreEqual(1, Interlocked.Increment(ref exclusive));
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
831 Interlocked.Decrement(ref exclusive);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
832 log.Enqueue("Writer #1 is finished");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
833 } finally {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
834 l.Release();
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
835 log.Enqueue("Writer #1 lock released");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
836 }
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
837 }
205
8200ab154c8a Added ResetState to RunnableComponent to reset in case of failure
cin
parents: 151
diff changeset
838 ).PromiseAll().Join(1000);
136
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
839 log.Enqueue("Done");
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
840 } catch(Exception error) {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
841 log.Enqueue(error.Message);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
842 throw;
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
843 } finally {
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
844 foreach (var m in log)
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
845 Console.WriteLine(m);
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
846 }
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
847 }
151
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
848
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
849 #if NET_4_5
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
850
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
851 [TestMethod]
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
852 public async void TaskInteropTest() {
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
853 var promise = new Promise<int>();
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
854 promise.Resolve(10);
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
855 var res = await promise;
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
856
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
857 Assert.AreEqual(10, res);
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
858 }
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
859
ec91a6dfa5b3 Added support for 'await' operator to promises
cin
parents: 149
diff changeset
860 #endif
77
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
861 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
862 }
91362ffbecf8 ported tests to mono
cin
parents: 76
diff changeset
863