annotate Implab.Test/AsyncTests.cs @ 201:d7cd7a83189a v2

TraceLog tests
author cin
date Mon, 17 Oct 2016 00:36:36 +0300
parents ec91a6dfa5b3
children 8200ab154c8a
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 )
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
339 .Bundle()
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 )
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
417 .Bundle()
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 )
124
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
493 .Bundle()
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 )
a336cb13c6a9 major update, added Drain mathod to AsyncQueue class
cin
parents: 122
diff changeset
596 .Bundle()
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 }
e9e7940c7d98 shared locks + tests
cin
parents: 125
diff changeset
838 ).Bundle().Join(1000);
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