1 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
2 #if !NO_TPL
3 
4 using System;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Text;
8 #if NUNIT
9 using NUnit.Framework;
10 using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
11 using TestMethodAttribute = NUnit.Framework.TestAttribute;
12 using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
13 #else
14 using Microsoft.VisualStudio.TestTools.UnitTesting;
15 #endif
16 using System.Threading;
17 
18 namespace Tests
19 {
20     public partial class AsyncTests
21     {
22         [TestMethod]
Concat_Null()23         public void Concat_Null()
24         {
25             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(null, AsyncEnumerable.Return(42)));
26             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(AsyncEnumerable.Return(42), null));
27             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(default(IAsyncEnumerable<int>[])));
28             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(default(IEnumerable<IAsyncEnumerable<int>>)));
29         }
30 
31         [TestMethod]
Concat1()32         public void Concat1()
33         {
34             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
35 
36             var e = ys.GetEnumerator();
37             HasNext(e, 1);
38             HasNext(e, 2);
39             HasNext(e, 3);
40             HasNext(e, 4);
41             HasNext(e, 5);
42             HasNext(e, 6);
43             NoNext(e);
44         }
45 
46         [TestMethod]
Concat2()47         public void Concat2()
48         {
49             var ex = new Exception("Bang");
50             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex));
51 
52             var e = ys.GetEnumerator();
53             HasNext(e, 1);
54             HasNext(e, 2);
55             HasNext(e, 3);
56             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
57         }
58 
59         [TestMethod]
Concat3()60         public void Concat3()
61         {
62             var ex = new Exception("Bang");
63             var ys = AsyncEnumerable.Throw<int>(ex).Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
64 
65             var e = ys.GetEnumerator();
66             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
67         }
68 
69         [TestMethod]
Concat4()70         public void Concat4()
71         {
72             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
73             var ys = new[] { 4, 5 }.ToAsyncEnumerable();
74             var zs = new[] { 6, 7, 8 }.ToAsyncEnumerable();
75 
76             var res = AsyncEnumerable.Concat(xs, ys, zs);
77 
78             var e = res.GetEnumerator();
79             HasNext(e, 1);
80             HasNext(e, 2);
81             HasNext(e, 3);
82             HasNext(e, 4);
83             HasNext(e, 5);
84             HasNext(e, 6);
85             HasNext(e, 7);
86             HasNext(e, 8);
87             NoNext(e);
88         }
89 
90         [TestMethod]
Concat5()91         public void Concat5()
92         {
93             var ex = new Exception("Bang");
94             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
95             var ys = new[] { 4, 5 }.ToAsyncEnumerable();
96             var zs = AsyncEnumerable.Throw<int>(ex);
97 
98             var res = AsyncEnumerable.Concat(xs, ys, zs);
99 
100             var e = res.GetEnumerator();
101             HasNext(e, 1);
102             HasNext(e, 2);
103             HasNext(e, 3);
104             HasNext(e, 4);
105             HasNext(e, 5);
106             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
107         }
108 
109         [TestMethod]
Concat6()110         public void Concat6()
111         {
112             var res = AsyncEnumerable.Concat(ConcatXss());
113 
114             var e = res.GetEnumerator();
115             HasNext(e, 1);
116             HasNext(e, 2);
117             HasNext(e, 3);
118             HasNext(e, 4);
119             HasNext(e, 5);
120             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
121         }
122 
ConcatXss()123         static IEnumerable<IAsyncEnumerable<int>> ConcatXss()
124         {
125             yield return new[] { 1, 2, 3 }.ToAsyncEnumerable();
126             yield return new[] { 4, 5 }.ToAsyncEnumerable();
127             throw new Exception("Bang!");
128         }
129 
130         [TestMethod]
Zip_Null()131         public void Zip_Null()
132         {
133             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(null, AsyncEnumerable.Return(42), (x, y) => x + y));
134             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(AsyncEnumerable.Return(42), null, (x, y) => x + y));
135             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
136         }
137 
138         [TestMethod]
Zip1()139         public void Zip1()
140         {
141             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
142             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
143             var res = xs.Zip(ys, (x, y) => x * y);
144 
145             var e = res.GetEnumerator();
146             HasNext(e, 1 * 4);
147             HasNext(e, 2 * 5);
148             HasNext(e, 3 * 6);
149             NoNext(e);
150         }
151 
152         [TestMethod]
Zip2()153         public void Zip2()
154         {
155             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
156             var ys = new[] { 4, 5, 6, 7 }.ToAsyncEnumerable();
157             var res = xs.Zip(ys, (x, y) => x * y);
158 
159             var e = res.GetEnumerator();
160             HasNext(e, 1 * 4);
161             HasNext(e, 2 * 5);
162             HasNext(e, 3 * 6);
163             NoNext(e);
164         }
165 
166         [TestMethod]
Zip3()167         public void Zip3()
168         {
169             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
170             var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
171             var res = xs.Zip(ys, (x, y) => x * y);
172 
173             var e = res.GetEnumerator();
174             HasNext(e, 1 * 4);
175             HasNext(e, 2 * 5);
176             HasNext(e, 3 * 6);
177             NoNext(e);
178         }
179 
180         [TestMethod]
Zip4()181         public void Zip4()
182         {
183             var ex = new Exception("Bang!");
184             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
185             var ys = AsyncEnumerable.Throw<int>(ex);
186             var res = xs.Zip(ys, (x, y) => x * y);
187 
188             var e = res.GetEnumerator();
189             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
190         }
191 
192         [TestMethod]
Zip5()193         public void Zip5()
194         {
195             var ex = new Exception("Bang!");
196             var xs = AsyncEnumerable.Throw<int>(ex);
197             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
198             var res = xs.Zip(ys, (x, y) => x * y);
199 
200             var e = res.GetEnumerator();
201             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
202         }
203 
204         [TestMethod]
Zip6()205         public void Zip6()
206         {
207             var ex = new Exception("Bang!");
208             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
209             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
210             var res = xs.Zip(ys, (x, y) => { if (x > 0) throw ex; return x * y; });
211 
212             var e = res.GetEnumerator();
213             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
214         }
215 
216         [TestMethod]
Union_Null()217         public void Union_Null()
218         {
219             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(null, AsyncEnumerable.Return(42)));
220             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), null));
221 
222             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(null, AsyncEnumerable.Return(42), new Eq()));
223             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), null, new Eq()));
224             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
225         }
226 
227         [TestMethod]
Union1()228         public void Union1()
229         {
230             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
231             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
232             var res = xs.Union(ys);
233 
234             var e = res.GetEnumerator();
235             HasNext(e, 1);
236             HasNext(e, 2);
237             HasNext(e, 3);
238             HasNext(e, 5);
239             HasNext(e, 4);
240             NoNext(e);
241         }
242 
243         [TestMethod]
Union2()244         public void Union2()
245         {
246             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
247             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
248             var res = xs.Union(ys, new Eq());
249 
250             var e = res.GetEnumerator();
251             HasNext(e, 1);
252             HasNext(e, 2);
253             HasNext(e, -3);
254             HasNext(e, 5);
255             HasNext(e, 4);
256             NoNext(e);
257         }
258 
259         [TestMethod]
Intersect_Null()260         public void Intersect_Null()
261         {
262             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(null, AsyncEnumerable.Return(42)));
263             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), null));
264 
265             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(null, AsyncEnumerable.Return(42), new Eq()));
266             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), null, new Eq()));
267             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
268         }
269 
270         [TestMethod]
Intersect1()271         public void Intersect1()
272         {
273             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
274             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
275             var res = xs.Intersect(ys);
276 
277             var e = res.GetEnumerator();
278             HasNext(e, 1);
279             HasNext(e, 3);
280             NoNext(e);
281         }
282 
283         [TestMethod]
Intersect2()284         public void Intersect2()
285         {
286             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
287             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
288             var res = xs.Intersect(ys, new Eq());
289 
290             var e = res.GetEnumerator();
291             HasNext(e, 1);
292             HasNext(e, -3);
293             NoNext(e);
294         }
295 
296         [TestMethod]
Except_Null()297         public void Except_Null()
298         {
299             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(null, AsyncEnumerable.Return(42)));
300             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), null));
301 
302             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(null, AsyncEnumerable.Return(42), new Eq()));
303             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), null, new Eq()));
304             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
305         }
306 
307         [TestMethod]
Except1()308         public void Except1()
309         {
310             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
311             var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
312             var res = xs.Except(ys);
313 
314             var e = res.GetEnumerator();
315             HasNext(e, 2);
316             NoNext(e);
317         }
318 
319         [TestMethod]
Except2()320         public void Except2()
321         {
322             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
323             var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
324             var res = xs.Except(ys, new Eq());
325 
326             var e = res.GetEnumerator();
327             HasNext(e, 2);
328             NoNext(e);
329         }
330 
331         [TestMethod]
SequenceEqual_Null()332         public void SequenceEqual_Null()
333         {
334             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42)));
335             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null));
336 
337             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq()));
338             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq()));
339             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
340 
341             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), CancellationToken.None));
342             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
343 
344             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None));
345             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None));
346             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None));
347         }
348 
349         [TestMethod]
SequenceEqual1()350         public void SequenceEqual1()
351         {
352             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
353             var res = xs.SequenceEqual(xs);
354             Assert.IsTrue(res.Result);
355         }
356 
357         [TestMethod]
SequenceEqual2()358         public void SequenceEqual2()
359         {
360             var xs = AsyncEnumerable.Empty<int>();
361             var res = xs.SequenceEqual(xs);
362             Assert.IsTrue(res.Result);
363         }
364 
365         [TestMethod]
SequenceEqual3()366         public void SequenceEqual3()
367         {
368             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
369             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
370             var res = xs.SequenceEqual(ys);
371             Assert.IsFalse(res.Result);
372         }
373 
374         [TestMethod]
SequenceEqual4()375         public void SequenceEqual4()
376         {
377             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
378             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
379             var res = xs.SequenceEqual(ys);
380             Assert.IsFalse(res.Result);
381         }
382 
383         [TestMethod]
SequenceEqual5()384         public void SequenceEqual5()
385         {
386             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
387             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
388             var res = xs.SequenceEqual(ys);
389             Assert.IsFalse(res.Result);
390         }
391 
392         [TestMethod]
SequenceEqual6()393         public void SequenceEqual6()
394         {
395             var ex = new Exception("Bang!");
396             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
397             var ys = AsyncEnumerable.Throw<int>(ex);
398             var res = xs.SequenceEqual(ys);
399 
400             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
401         }
402 
403         [TestMethod]
SequenceEqual7()404         public void SequenceEqual7()
405         {
406             var ex = new Exception("Bang!");
407             var xs = AsyncEnumerable.Throw<int>(ex);
408             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
409             var res = xs.SequenceEqual(ys);
410 
411             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
412         }
413 
414         [TestMethod]
SequenceEqual8()415         public void SequenceEqual8()
416         {
417             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
418             var res = xs.SequenceEqual(xs, new Eq());
419             Assert.IsTrue(res.Result);
420         }
421 
422         [TestMethod]
SequenceEqual9()423         public void SequenceEqual9()
424         {
425             var xs = AsyncEnumerable.Empty<int>();
426             var res = xs.SequenceEqual(xs, new Eq());
427             Assert.IsTrue(res.Result);
428         }
429 
430         [TestMethod]
SequenceEqual10()431         public void SequenceEqual10()
432         {
433             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
434             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
435             var res = xs.SequenceEqual(ys, new Eq());
436             Assert.IsFalse(res.Result);
437         }
438 
439         [TestMethod]
SequenceEqual11()440         public void SequenceEqual11()
441         {
442             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
443             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
444             var res = xs.SequenceEqual(ys, new Eq());
445             Assert.IsFalse(res.Result);
446         }
447 
448         [TestMethod]
SequenceEqual12()449         public void SequenceEqual12()
450         {
451             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
452             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
453             var res = xs.SequenceEqual(ys, new Eq());
454             Assert.IsFalse(res.Result);
455         }
456 
457         [TestMethod]
SequenceEqual13()458         public void SequenceEqual13()
459         {
460             var ex = new Exception("Bang!");
461             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
462             var ys = AsyncEnumerable.Throw<int>(ex);
463             var res = xs.SequenceEqual(ys, new Eq());
464 
465             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
466         }
467 
468         [TestMethod]
SequenceEqual14()469         public void SequenceEqual14()
470         {
471             var ex = new Exception("Bang!");
472             var xs = AsyncEnumerable.Throw<int>(ex);
473             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
474             var res = xs.SequenceEqual(ys, new Eq());
475 
476             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
477         }
478 
479         [TestMethod]
SequenceEqual15()480         public void SequenceEqual15()
481         {
482             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
483             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
484             var res = xs.SequenceEqual(ys, new Eq());
485             Assert.IsTrue(res.Result);
486         }
487 
488         [TestMethod]
SequenceEqual16()489         public void SequenceEqual16()
490         {
491             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
492             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
493             var res = xs.SequenceEqual(ys, new EqEx());
494             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
495         }
496 
497         class EqEx : IEqualityComparer<int>
498         {
Equals(int x, int y)499             public bool Equals(int x, int y)
500             {
501                 throw new NotImplementedException();
502             }
503 
GetHashCode(int obj)504             public int GetHashCode(int obj)
505             {
506                 throw new NotImplementedException();
507             }
508         }
509 
510         [TestMethod]
GroupJoin_Null()511         public void GroupJoin_Null()
512         {
513             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
514             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x));
515             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x));
516             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x));
517             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null));
518 
519             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
520             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
521             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer<int>.Default));
522             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer<int>.Default));
523             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer<int>.Default));
524             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
525         }
526 
527         [TestMethod]
GroupJoin1()528         public void GroupJoin1()
529         {
530             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
531             var ys = new[] { 4, 7, 6, 2, 3, 4, 8, 9 }.ToAsyncEnumerable();
532 
533             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
534 
535             var e = res.GetEnumerator();
536             HasNext(e, "0 - 639");
537             HasNext(e, "1 - 474");
538             HasNext(e, "2 - 28");
539             NoNext(e);
540         }
541 
542         [TestMethod]
GroupJoin2()543         public void GroupJoin2()
544         {
545             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
546             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
547 
548             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
549 
550             var e = res.GetEnumerator();
551             HasNext(e, "0 - 36");
552             HasNext(e, "1 - 4");
553             HasNext(e, "2 - ");
554             NoNext(e);
555         }
556 
557         [TestMethod]
GroupJoin3()558         public void GroupJoin3()
559         {
560             var ex = new Exception("Bang!");
561             var xs = AsyncEnumerable.Throw<int>(ex);
562             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
563 
564             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
565 
566             var e = res.GetEnumerator();
567             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
568         }
569 
570         [TestMethod]
GroupJoin4()571         public void GroupJoin4()
572         {
573             var ex = new Exception("Bang!");
574             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
575             var ys = AsyncEnumerable.Throw<int>(ex);
576 
577             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
578 
579             var e = res.GetEnumerator();
580             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
581         }
582 
583         [TestMethod]
GroupJoin5()584         public void GroupJoin5()
585         {
586             var ex = new Exception("Bang!");
587             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
588             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
589 
590             var res = xs.GroupJoin(ys, x => { throw ex; }, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
591 
592             var e = res.GetEnumerator();
593             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
594         }
595 
596         [TestMethod]
GroupJoin6()597         public void GroupJoin6()
598         {
599             var ex = new Exception("Bang!");
600             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
601             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
602 
603             var res = xs.GroupJoin(ys, x => x % 3, y => { throw ex; }, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
604 
605             var e = res.GetEnumerator();
606             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
607         }
608 
609         [TestMethod]
GroupJoin7()610         public void GroupJoin7()
611         {
612             var ex = new Exception("Bang!");
613             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
614             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
615 
616             var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => {
617                 if (x == 1)
618                     throw ex;
619                 return x + " - " + i.Aggregate("", (s, j) => s + j).Result;
620             });
621 
622             var e = res.GetEnumerator();
623             HasNext(e, "0 - 36");
624             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
625         }
626 
627         [TestMethod]
Join_Null()628         public void Join_Null()
629         {
630             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
631             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x));
632             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x));
633             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x));
634             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null));
635 
636             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
637             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
638             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer<int>.Default));
639             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer<int>.Default));
640             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer<int>.Default));
641             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
642         }
643 
644         [TestMethod]
Join1()645         public void Join1()
646         {
647             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
648             var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
649 
650             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
651 
652             var e = res.GetEnumerator();
653             HasNext(e, 0 + 3);
654             HasNext(e, 0 + 6);
655             HasNext(e, 1 + 4);
656             NoNext(e);
657         }
658 
659         [TestMethod]
Join2()660         public void Join2()
661         {
662             var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable();
663             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
664 
665             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
666 
667             var e = res.GetEnumerator();
668             HasNext(e, 3 + 0);
669             HasNext(e, 6 + 0);
670             HasNext(e, 4 + 1);
671             NoNext(e);
672         }
673 
674         [TestMethod]
Join3()675         public void Join3()
676         {
677             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
678             var ys = new[] { 3, 6 }.ToAsyncEnumerable();
679 
680             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
681 
682             var e = res.GetEnumerator();
683             HasNext(e, 0 + 3);
684             HasNext(e, 0 + 6);
685             NoNext(e);
686         }
687 
688         [TestMethod]
Join4()689         public void Join4()
690         {
691             var xs = new[] { 3, 6 }.ToAsyncEnumerable();
692             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
693 
694             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
695 
696             var e = res.GetEnumerator();
697             HasNext(e, 3 + 0);
698             HasNext(e, 6 + 0);
699             NoNext(e);
700         }
701 
702         [TestMethod]
Join5()703         public void Join5()
704         {
705             var ex = new Exception("Bang!");
706             var xs = AsyncEnumerable.Throw<int>(ex);
707             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
708 
709             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
710 
711             var e = res.GetEnumerator();
712             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
713         }
714 
715         [TestMethod]
Join6()716         public void Join6()
717         {
718             var ex = new Exception("Bang!");
719             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
720             var ys = AsyncEnumerable.Throw<int>(ex);
721 
722             var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
723 
724             var e = res.GetEnumerator();
725             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
726         }
727 
728         [TestMethod]
Join7()729         public void Join7()
730         {
731             var ex = new Exception("Bang!");
732             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
733             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
734 
735             var res = xs.Join(ys, x => { throw ex; }, y => y, (x, y) => x + y);
736 
737             var e = res.GetEnumerator();
738             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
739         }
740 
741         [TestMethod]
Join8()742         public void Join8()
743         {
744             var ex = new Exception("Bang!");
745             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
746             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
747 
748             var res = xs.Join(ys, x => x, y => { throw ex; }, (x, y) => x + y);
749 
750             var e = res.GetEnumerator();
751             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
752         }
753 
754         [TestMethod]
Join9()755         public void Join9()
756         {
757             var ex = new Exception("Bang!");
758             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
759             var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
760 
761             var res = xs.Join<int, int, int, int>(ys, x => x, y => y, (x, y) => { throw ex; });
762 
763             var e = res.GetEnumerator();
764             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
765         }
766 
767         [TestMethod]
SelectManyMultiple_Null()768         public void SelectManyMultiple_Null()
769         {
770             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(default(IAsyncEnumerable<int>), AsyncEnumerable.Return(42)));
771             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(AsyncEnumerable.Return(42), default(IAsyncEnumerable<int>)));
772         }
773 
774         [TestMethod]
SelectManyMultiple1()775         public void SelectManyMultiple1()
776         {
777             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
778             var ys = new[] { 3, 4 }.ToAsyncEnumerable();
779 
780             var res = xs.SelectMany(ys);
781 
782             var e = res.GetEnumerator();
783             HasNext(e, 3);
784             HasNext(e, 4);
785             HasNext(e, 3);
786             HasNext(e, 4);
787             HasNext(e, 3);
788             HasNext(e, 4);
789             NoNext(e);
790         }
791     }
792 }
793 
794 #endif