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.Collections;
17 using System.Threading;
18 
19 namespace Tests
20 {
21     public partial class AsyncTests
22     {
23         [TestMethod]
Aggregate_Null()24         public void Aggregate_Null()
25         {
26             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y));
27             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null));
28 
29             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y));
30             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null));
31 
32             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z));
33             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z));
34             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null));
35 
36             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(null, (x, y) => x + y, CancellationToken.None));
37             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
38 
39             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(null, 0, (x, y) => x + y, CancellationToken.None));
40             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int>(AsyncEnumerable.Return(42), 0, null, CancellationToken.None));
41 
42             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(null, 0, (x, y) => x + y, z => z, CancellationToken.None));
43             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, null, z => z, CancellationToken.None));
44             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Aggregate<int, int, int>(AsyncEnumerable.Return(42), 0, (x, y) => x + y, null, CancellationToken.None));
45         }
46 
47         [TestMethod]
Aggregate1()48         public void Aggregate1()
49         {
50             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
51             var ys = xs.Aggregate((x, y) => x * y);
52             Assert.AreEqual(ys.Result, 24);
53         }
54 
55         [TestMethod]
Aggregate2()56         public void Aggregate2()
57         {
58             var xs = new int[0].ToAsyncEnumerable();
59             var ys = xs.Aggregate((x, y) => x * y);
60             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
61         }
62 
63         [TestMethod]
Aggregate3()64         public void Aggregate3()
65         {
66             var ex = new Exception("Bang!");
67             var xs = AsyncEnumerable.Throw<int>(ex);
68             var ys = xs.Aggregate((x, y) => x * y);
69             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
70         }
71 
72         [TestMethod]
Aggregate4()73         public void Aggregate4()
74         {
75             var ex = new Exception("Bang!");
76             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
77             var ys = xs.Aggregate((x, y) => { throw ex; });
78             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
79         }
80 
81         [TestMethod]
Aggregate5()82         public void Aggregate5()
83         {
84             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
85             var ys = xs.Aggregate(1, (x, y) => x * y);
86             Assert.AreEqual(ys.Result, 24);
87         }
88 
89         [TestMethod]
Aggregate6()90         public void Aggregate6()
91         {
92             var xs = new int[0].ToAsyncEnumerable();
93             var ys = xs.Aggregate(1, (x, y) => x * y);
94             Assert.AreEqual(ys.Result, 1);
95         }
96 
97         [TestMethod]
Aggregate7()98         public void Aggregate7()
99         {
100             var ex = new Exception("Bang!");
101             var xs = AsyncEnumerable.Throw<int>(ex);
102             var ys = xs.Aggregate(1, (x, y) => x * y);
103             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
104         }
105 
106         [TestMethod]
Aggregate8()107         public void Aggregate8()
108         {
109             var ex = new Exception("Bang!");
110             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
111             var ys = xs.Aggregate(1, (x, y) => { throw ex; });
112             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
113         }
114 
115         [TestMethod]
Aggregate9()116         public void Aggregate9()
117         {
118             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
119             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
120             Assert.AreEqual(ys.Result, 25);
121         }
122 
123         [TestMethod]
Aggregate10()124         public void Aggregate10()
125         {
126             var xs = new int[0].ToAsyncEnumerable();
127             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
128             Assert.AreEqual(ys.Result, 2);
129         }
130 
131         [TestMethod]
Aggregate11()132         public void Aggregate11()
133         {
134             var ex = new Exception("Bang!");
135             var xs = AsyncEnumerable.Throw<int>(ex);
136             var ys = xs.Aggregate(1, (x, y) => x * y, x => x + 1);
137             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
138         }
139 
140         [TestMethod]
Aggregate12()141         public void Aggregate12()
142         {
143             var ex = new Exception("Bang!");
144             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
145             var ys = xs.Aggregate(1, (x, y) => { throw ex; }, x => x + 1);
146             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
147         }
148 
149         [TestMethod]
Aggregate13()150         public void Aggregate13()
151         {
152             var ex = new Exception("Bang!");
153             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
154             var ys = xs.Aggregate<int, int, int>(1, (x, y) => x * y, x => { throw ex; });
155             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
156         }
157 
158         [TestMethod]
Count_Null()159         public void Count_Null()
160         {
161             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null));
162             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true));
163             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null));
164 
165             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, CancellationToken.None));
166             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(null, x => true, CancellationToken.None));
167             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Count<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
168         }
169 
170         [TestMethod]
Count1()171         public void Count1()
172         {
173             Assert.AreEqual(new int[0].ToAsyncEnumerable().Count().Result, 0);
174             Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count().Result, 3);
175             AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count().Wait());
176         }
177 
178         [TestMethod]
Count2()179         public void Count2()
180         {
181             Assert.AreEqual(new int[0].ToAsyncEnumerable().Count(x => x < 3).Result, 0);
182             Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => x < 3).Result, 2);
183             AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).Count(x => x < 3).Wait());
184         }
185 
186         [TestMethod]
Count3()187         public void Count3()
188         {
189             var ex = new Exception("Bang!");
190             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Count(x => { throw ex; });
191             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
192         }
193 
194         [TestMethod]
LongCount_Null()195         public void LongCount_Null()
196         {
197             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null));
198             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true));
199             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null));
200 
201             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, CancellationToken.None));
202             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(null, x => true, CancellationToken.None));
203             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LongCount<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
204         }
205 
206         [TestMethod]
LongCount1()207         public void LongCount1()
208         {
209             Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount().Result, 0);
210             Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount().Result, 3);
211             AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount().Wait());
212         }
213 
214         [TestMethod]
LongCount2()215         public void LongCount2()
216         {
217             Assert.AreEqual(new int[0].ToAsyncEnumerable().LongCount(x => x < 3).Result, 0);
218             Assert.AreEqual(new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => x < 3).Result, 2);
219             AssertThrows<AggregateException>(() => AsyncEnumerable.Throw<int>(new Exception("Bang!")).LongCount(x => x < 3).Wait());
220         }
221 
222         [TestMethod]
LongCount3()223         public void LongCount3()
224         {
225             var ex = new Exception("Bang!");
226             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCount(x => { throw ex; });
227             AssertThrows<Exception>(() => ys.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
228         }
229 
230         [TestMethod]
All_Null()231         public void All_Null()
232         {
233             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true));
234             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null));
235 
236             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(null, x => true, CancellationToken.None));
237             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.All<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
238         }
239 
240         [TestMethod]
All1()241         public void All1()
242         {
243             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0);
244             Assert.IsFalse(res.Result);
245         }
246 
247         [TestMethod]
All2()248         public void All2()
249         {
250             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => x % 2 == 0);
251             Assert.IsTrue(res.Result);
252         }
253 
254         [TestMethod]
All3()255         public void All3()
256         {
257             var ex = new Exception("Bang!");
258             var res = AsyncEnumerable.Throw<int>(ex).All(x => x % 2 == 0);
259             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
260         }
261 
262         [TestMethod]
All4()263         public void All4()
264         {
265             var ex = new Exception("Bang!");
266             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().All(x => { throw ex; });
267             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
268         }
269 
270         [TestMethod]
Any_Null()271         public void Any_Null()
272         {
273             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null));
274             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true));
275             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null));
276 
277             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, CancellationToken.None));
278             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(null, x => true, CancellationToken.None));
279             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Any<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
280         }
281 
282         [TestMethod]
Any1()283         public void Any1()
284         {
285             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any(x => x % 2 == 0);
286             Assert.IsTrue(res.Result);
287         }
288 
289         [TestMethod]
Any2()290         public void Any2()
291         {
292             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => x % 2 != 0);
293             Assert.IsFalse(res.Result);
294         }
295 
296         [TestMethod]
Any3()297         public void Any3()
298         {
299             var ex = new Exception("Bang!");
300             var res = AsyncEnumerable.Throw<int>(ex).Any(x => x % 2 == 0);
301             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
302         }
303 
304         [TestMethod]
Any4()305         public void Any4()
306         {
307             var ex = new Exception("Bang!");
308             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().Any(x => { throw ex; });
309             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
310         }
311 
312         [TestMethod]
Any5()313         public void Any5()
314         {
315             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().Any();
316             Assert.IsTrue(res.Result);
317         }
318 
319         [TestMethod]
Any6()320         public void Any6()
321         {
322             var res = new int[0].ToAsyncEnumerable().Any();
323             Assert.IsFalse(res.Result);
324         }
325 
326         [TestMethod]
Contains_Null()327         public void Contains_Null()
328         {
329             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42));
330             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default));
331             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null));
332 
333             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, CancellationToken.None));
334             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(null, 42, EqualityComparer<int>.Default, CancellationToken.None));
335             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Contains<int>(AsyncEnumerable.Return(42), 42, null, CancellationToken.None));
336         }
337 
338         [TestMethod]
Contains1()339         public void Contains1()
340         {
341             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
342             var ys = xs.Contains(3);
343             Assert.IsTrue(ys.Result);
344         }
345 
346         [TestMethod]
Contains2()347         public void Contains2()
348         {
349             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
350             var ys = xs.Contains(6);
351             Assert.IsFalse(ys.Result);
352         }
353 
354         [TestMethod]
Contains3()355         public void Contains3()
356         {
357             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
358             var ys = xs.Contains(-3, new Eq());
359             Assert.IsTrue(ys.Result);
360         }
361 
362         [TestMethod]
Contains4()363         public void Contains4()
364         {
365             var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable();
366             var ys = xs.Contains(-6, new Eq());
367             Assert.IsFalse(ys.Result);
368         }
369 
370         class Eq : IEqualityComparer<int>
371         {
Equals(int x, int y)372             public bool Equals(int x, int y)
373             {
374                 return EqualityComparer<int>.Default.Equals(Math.Abs(x), Math.Abs(y));
375             }
376 
GetHashCode(int obj)377             public int GetHashCode(int obj)
378             {
379                 return EqualityComparer<int>.Default.GetHashCode(Math.Abs(obj));
380             }
381         }
382 
383         [TestMethod]
First_Null()384         public void First_Null()
385         {
386             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null));
387             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true));
388             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null));
389 
390             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, CancellationToken.None));
391             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(null, x => true, CancellationToken.None));
392             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.First<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
393         }
394 
395         [TestMethod]
First1()396         public void First1()
397         {
398             var res = AsyncEnumerable.Empty<int>().First();
399             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
400         }
401 
402         [TestMethod]
First2()403         public void First2()
404         {
405             var res = AsyncEnumerable.Empty<int>().First(x => true);
406             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
407         }
408 
409         [TestMethod]
First3()410         public void First3()
411         {
412             var res = AsyncEnumerable.Return(42).First(x => x % 2 != 0);
413             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
414         }
415 
416         [TestMethod]
First4()417         public void First4()
418         {
419             var res = AsyncEnumerable.Return(42).First();
420             Assert.AreEqual(42, res.Result);
421         }
422 
423         [TestMethod]
First5()424         public void First5()
425         {
426             var res = AsyncEnumerable.Return(42).First(x => x % 2 == 0);
427             Assert.AreEqual(42, res.Result);
428         }
429 
430         [TestMethod]
First6()431         public void First6()
432         {
433             var ex = new Exception("Bang!");
434             var res = AsyncEnumerable.Throw<int>(ex).First();
435             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
436         }
437 
438         [TestMethod]
First7()439         public void First7()
440         {
441             var ex = new Exception("Bang!");
442             var res = AsyncEnumerable.Throw<int>(ex).First(x => true);
443             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
444         }
445 
446         [TestMethod]
First8()447         public void First8()
448         {
449             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First();
450             Assert.AreEqual(42, res.Result);
451         }
452 
453         [TestMethod]
First9()454         public void First9()
455         {
456             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().First(x => x % 2 != 0);
457             Assert.AreEqual(45, res.Result);
458         }
459 
460         [TestMethod]
FirstOrDefault_Null()461         public void FirstOrDefault_Null()
462         {
463             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null));
464             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true));
465             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null));
466 
467             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, CancellationToken.None));
468             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(null, x => true, CancellationToken.None));
469             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
470         }
471 
472         [TestMethod]
FirstOrDefault1()473         public void FirstOrDefault1()
474         {
475             var res = AsyncEnumerable.Empty<int>().FirstOrDefault();
476             Assert.AreEqual(0, res.Result);
477         }
478 
479         [TestMethod]
FirstOrDefault2()480         public void FirstOrDefault2()
481         {
482             var res = AsyncEnumerable.Empty<int>().FirstOrDefault(x => true);
483             Assert.AreEqual(0, res.Result);
484         }
485 
486         [TestMethod]
FirstOrDefault3()487         public void FirstOrDefault3()
488         {
489             var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 != 0);
490             Assert.AreEqual(0, res.Result);
491         }
492 
493         [TestMethod]
FirstOrDefault4()494         public void FirstOrDefault4()
495         {
496             var res = AsyncEnumerable.Return(42).FirstOrDefault();
497             Assert.AreEqual(42, res.Result);
498         }
499 
500         [TestMethod]
FirstOrDefault5()501         public void FirstOrDefault5()
502         {
503             var res = AsyncEnumerable.Return(42).FirstOrDefault(x => x % 2 == 0);
504             Assert.AreEqual(42, res.Result);
505         }
506 
507         [TestMethod]
FirstOrDefault6()508         public void FirstOrDefault6()
509         {
510             var ex = new Exception("Bang!");
511             var res = AsyncEnumerable.Throw<int>(ex).FirstOrDefault();
512             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
513         }
514 
515         [TestMethod]
FirstOrDefault7()516         public void FirstOrDefault7()
517         {
518             var ex = new Exception("Bang!");
519             var res = AsyncEnumerable.Throw<int>(ex).FirstOrDefault(x => true);
520             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
521         }
522 
523         [TestMethod]
FirstOrDefault8()524         public void FirstOrDefault8()
525         {
526             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault();
527             Assert.AreEqual(42, res.Result);
528         }
529 
530         [TestMethod]
FirstOrDefault9()531         public void FirstOrDefault9()
532         {
533             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x % 2 != 0);
534             Assert.AreEqual(45, res.Result);
535         }
536 
537         [TestMethod]
FirstOrDefault10()538         public void FirstOrDefault10()
539         {
540             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefault(x => x < 10);
541             Assert.AreEqual(0, res.Result);
542         }
543 
544         [TestMethod]
Last_Null()545         public void Last_Null()
546         {
547             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null));
548             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true));
549             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null));
550 
551             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, CancellationToken.None));
552             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(null, x => true, CancellationToken.None));
553             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Last<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
554         }
555 
556         [TestMethod]
Last1()557         public void Last1()
558         {
559             var res = AsyncEnumerable.Empty<int>().Last();
560             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
561         }
562 
563         [TestMethod]
Last2()564         public void Last2()
565         {
566             var res = AsyncEnumerable.Empty<int>().Last(x => true);
567             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
568         }
569 
570         [TestMethod]
Last3()571         public void Last3()
572         {
573             var res = AsyncEnumerable.Return(42).Last(x => x % 2 != 0);
574             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
575         }
576 
577         [TestMethod]
Last4()578         public void Last4()
579         {
580             var res = AsyncEnumerable.Return(42).Last();
581             Assert.AreEqual(42, res.Result);
582         }
583 
584         [TestMethod]
Last5()585         public void Last5()
586         {
587             var res = AsyncEnumerable.Return(42).Last(x => x % 2 == 0);
588             Assert.AreEqual(42, res.Result);
589         }
590 
591         [TestMethod]
Last6()592         public void Last6()
593         {
594             var ex = new Exception("Bang!");
595             var res = AsyncEnumerable.Throw<int>(ex).Last();
596             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
597         }
598 
599         [TestMethod]
Last7()600         public void Last7()
601         {
602             var ex = new Exception("Bang!");
603             var res = AsyncEnumerable.Throw<int>(ex).Last(x => true);
604             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
605         }
606 
607         [TestMethod]
Last8()608         public void Last8()
609         {
610             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Last();
611             Assert.AreEqual(90, res.Result);
612         }
613 
614         [TestMethod]
Last9()615         public void Last9()
616         {
617             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Last(x => x % 2 != 0);
618             Assert.AreEqual(45, res.Result);
619         }
620 
621         [TestMethod]
LastOrDefault_Null()622         public void LastOrDefault_Null()
623         {
624             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null));
625             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true));
626             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null));
627 
628             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, CancellationToken.None));
629             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(null, x => true, CancellationToken.None));
630             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.LastOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
631         }
632 
633         [TestMethod]
LastOrDefault1()634         public void LastOrDefault1()
635         {
636             var res = AsyncEnumerable.Empty<int>().LastOrDefault();
637             Assert.AreEqual(0, res.Result);
638         }
639 
640         [TestMethod]
LastOrDefault2()641         public void LastOrDefault2()
642         {
643             var res = AsyncEnumerable.Empty<int>().LastOrDefault(x => true);
644             Assert.AreEqual(0, res.Result);
645         }
646 
647         [TestMethod]
LastOrDefault3()648         public void LastOrDefault3()
649         {
650             var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 != 0);
651             Assert.AreEqual(0, res.Result);
652         }
653 
654         [TestMethod]
LastOrDefault4()655         public void LastOrDefault4()
656         {
657             var res = AsyncEnumerable.Return(42).LastOrDefault();
658             Assert.AreEqual(42, res.Result);
659         }
660 
661         [TestMethod]
LastOrDefault5()662         public void LastOrDefault5()
663         {
664             var res = AsyncEnumerable.Return(42).LastOrDefault(x => x % 2 == 0);
665             Assert.AreEqual(42, res.Result);
666         }
667 
668         [TestMethod]
LastOrDefault6()669         public void LastOrDefault6()
670         {
671             var ex = new Exception("Bang!");
672             var res = AsyncEnumerable.Throw<int>(ex).LastOrDefault();
673             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
674         }
675 
676         [TestMethod]
LastOrDefault7()677         public void LastOrDefault7()
678         {
679             var ex = new Exception("Bang!");
680             var res = AsyncEnumerable.Throw<int>(ex).LastOrDefault(x => true);
681             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
682         }
683 
684         [TestMethod]
LastOrDefault8()685         public void LastOrDefault8()
686         {
687             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault();
688             Assert.AreEqual(90, res.Result);
689         }
690 
691         [TestMethod]
LastOrDefault9()692         public void LastOrDefault9()
693         {
694             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x % 2 != 0);
695             Assert.AreEqual(45, res.Result);
696         }
697 
698         [TestMethod]
LastOrDefault10()699         public void LastOrDefault10()
700         {
701             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefault(x => x < 10);
702             Assert.AreEqual(0, res.Result);
703         }
704 
705         [TestMethod]
Single_Null()706         public void Single_Null()
707         {
708             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null));
709             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true));
710             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null));
711 
712             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, CancellationToken.None));
713             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(null, x => true, CancellationToken.None));
714             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Single<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
715         }
716 
717         [TestMethod]
Single1()718         public void Single1()
719         {
720             var res = AsyncEnumerable.Empty<int>().Single();
721             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
722         }
723 
724         [TestMethod]
Single2()725         public void Single2()
726         {
727             var res = AsyncEnumerable.Empty<int>().Single(x => true);
728             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
729         }
730 
731         [TestMethod]
Single3()732         public void Single3()
733         {
734             var res = AsyncEnumerable.Return(42).Single(x => x % 2 != 0);
735             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
736         }
737 
738         [TestMethod]
Single4()739         public void Single4()
740         {
741             var res = AsyncEnumerable.Return(42).Single();
742             Assert.AreEqual(42, res.Result);
743         }
744 
745         [TestMethod]
Single5()746         public void Single5()
747         {
748             var res = AsyncEnumerable.Return(42).Single(x => x % 2 == 0);
749             Assert.AreEqual(42, res.Result);
750         }
751 
752         [TestMethod]
Single6()753         public void Single6()
754         {
755             var ex = new Exception("Bang!");
756             var res = AsyncEnumerable.Throw<int>(ex).Single();
757             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
758         }
759 
760         [TestMethod]
Single7()761         public void Single7()
762         {
763             var ex = new Exception("Bang!");
764             var res = AsyncEnumerable.Throw<int>(ex).Single(x => true);
765             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
766         }
767 
768         [TestMethod]
Single8()769         public void Single8()
770         {
771             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single();
772             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
773         }
774 
775         [TestMethod]
Single9()776         public void Single9()
777         {
778             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0);
779             Assert.AreEqual(45, res.Result);
780         }
781 
782         [TestMethod]
Single10()783         public void Single10()
784         {
785             var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().Single(x => x % 2 != 0);
786             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
787         }
788 
789         [TestMethod]
SingleOrDefault_Null()790         public void SingleOrDefault_Null()
791         {
792             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null));
793             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true));
794             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null));
795 
796             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, CancellationToken.None));
797             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(null, x => true, CancellationToken.None));
798             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefault<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
799         }
800 
801         [TestMethod]
SingleOrDefault1()802         public void SingleOrDefault1()
803         {
804             var res = AsyncEnumerable.Empty<int>().SingleOrDefault();
805             Assert.AreEqual(0, res.Result);
806         }
807 
808         [TestMethod]
SingleOrDefault2()809         public void SingleOrDefault2()
810         {
811             var res = AsyncEnumerable.Empty<int>().SingleOrDefault(x => true);
812             Assert.AreEqual(0, res.Result);
813         }
814 
815         [TestMethod]
SingleOrDefault3()816         public void SingleOrDefault3()
817         {
818             var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 != 0);
819             Assert.AreEqual(0, res.Result);
820         }
821 
822         [TestMethod]
SingleOrDefault4()823         public void SingleOrDefault4()
824         {
825             var res = AsyncEnumerable.Return(42).SingleOrDefault();
826             Assert.AreEqual(42, res.Result);
827         }
828 
829         [TestMethod]
SingleOrDefault5()830         public void SingleOrDefault5()
831         {
832             var res = AsyncEnumerable.Return(42).SingleOrDefault(x => x % 2 == 0);
833             Assert.AreEqual(42, res.Result);
834         }
835 
836         [TestMethod]
SingleOrDefault6()837         public void SingleOrDefault6()
838         {
839             var ex = new Exception("Bang!");
840             var res = AsyncEnumerable.Throw<int>(ex).SingleOrDefault();
841             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
842         }
843 
844         [TestMethod]
SingleOrDefault7()845         public void SingleOrDefault7()
846         {
847             var ex = new Exception("Bang!");
848             var res = AsyncEnumerable.Throw<int>(ex).SingleOrDefault(x => true);
849             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
850         }
851 
852         [TestMethod]
SingleOrDefault8()853         public void SingleOrDefault8()
854         {
855             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault();
856             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
857         }
858 
859         [TestMethod]
SingleOrDefault9()860         public void SingleOrDefault9()
861         {
862             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x % 2 != 0);
863             Assert.AreEqual(45, res.Result);
864         }
865 
866         [TestMethod]
SingleOrDefault10()867         public void SingleOrDefault10()
868         {
869             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => x < 10);
870             Assert.AreEqual(0, res.Result);
871         }
872 
873         [TestMethod]
SingleOrDefault11()874         public void SingleOrDefault11()
875         {
876             var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefault(x => true);
877             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
878         }
879 
880         [TestMethod]
ElementAt_Null()881         public void ElementAt_Null()
882         {
883             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0));
884             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1));
885 
886             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAt<int>(null, 0, CancellationToken.None));
887             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAt<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
888         }
889 
890         [TestMethod]
ElementAt1()891         public void ElementAt1()
892         {
893             var res = AsyncEnumerable.Empty<int>().ElementAt(0);
894             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
895         }
896 
897         [TestMethod]
ElementAt2()898         public void ElementAt2()
899         {
900             var res = AsyncEnumerable.Return<int>(42).ElementAt(0);
901             Assert.AreEqual(42, res.Result);
902         }
903 
904         [TestMethod]
ElementAt3()905         public void ElementAt3()
906         {
907             var res = AsyncEnumerable.Return<int>(42).ElementAt(1);
908             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
909         }
910 
911         [TestMethod]
ElementAt4()912         public void ElementAt4()
913         {
914             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(1);
915             Assert.AreEqual(42, res.Result);
916         }
917 
918         [TestMethod]
ElementAt5()919         public void ElementAt5()
920         {
921             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAt(7);
922             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentOutOfRangeException);
923         }
924 
925         [TestMethod]
ElementAt6()926         public void ElementAt6()
927         {
928             var ex = new Exception("Bang!");
929             var res = AsyncEnumerable.Throw<int>(ex).ElementAt(15);
930             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
931         }
932 
933         [TestMethod]
ElementAtOrDefault_Null()934         public void ElementAtOrDefault_Null()
935         {
936             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0));
937             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1));
938 
939             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ElementAtOrDefault<int>(null, 0, CancellationToken.None));
940             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.ElementAtOrDefault<int>(AsyncEnumerable.Return(42), -1, CancellationToken.None));
941         }
942 
943         [TestMethod]
ElementAtOrDefault1()944         public void ElementAtOrDefault1()
945         {
946             var res = AsyncEnumerable.Empty<int>().ElementAtOrDefault(0);
947             Assert.AreEqual(0, res.Result);
948         }
949 
950         [TestMethod]
ElementAtOrDefault2()951         public void ElementAtOrDefault2()
952         {
953             var res = AsyncEnumerable.Return<int>(42).ElementAtOrDefault(0);
954             Assert.AreEqual(42, res.Result);
955         }
956 
957         [TestMethod]
ElementAtOrDefault3()958         public void ElementAtOrDefault3()
959         {
960             var res = AsyncEnumerable.Return<int>(42).ElementAtOrDefault(1);
961             Assert.AreEqual(0, res.Result);
962         }
963 
964         [TestMethod]
ElementAtOrDefault4()965         public void ElementAtOrDefault4()
966         {
967             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(1);
968             Assert.AreEqual(42, res.Result);
969         }
970 
971         [TestMethod]
ElementAtOrDefault5()972         public void ElementAtOrDefault5()
973         {
974             var res = new[] { 1, 42, 3 }.ToAsyncEnumerable().ElementAtOrDefault(7);
975             Assert.AreEqual(0, res.Result);
976         }
977 
978         [TestMethod]
ElementAtOrDefault6()979         public void ElementAtOrDefault6()
980         {
981             var ex = new Exception("Bang!");
982             var res = AsyncEnumerable.Throw<int>(ex).ElementAtOrDefault(15);
983             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
984         }
985 
986         [TestMethod]
ToList_Null()987         public void ToList_Null()
988         {
989             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null));
990             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToList<int>(null, CancellationToken.None));
991         }
992 
993         [TestMethod]
ToList1()994         public void ToList1()
995         {
996             var xs = new[] { 42, 25, 39 };
997             var res = xs.ToAsyncEnumerable().ToList();
998             Assert.IsTrue(res.Result.SequenceEqual(xs));
999         }
1000 
1001         [TestMethod]
ToList2()1002         public void ToList2()
1003         {
1004             var xs = AsyncEnumerable.Empty<int>();
1005             var res = xs.ToList();
1006             Assert.IsTrue(res.Result.Count == 0);
1007         }
1008 
1009         [TestMethod]
ToList3()1010         public void ToList3()
1011         {
1012             var ex = new Exception("Bang!");
1013             var res = AsyncEnumerable.Throw<int>(ex).ToList();
1014             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
1015         }
1016 
1017         [TestMethod]
ToArray_Null()1018         public void ToArray_Null()
1019         {
1020             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null));
1021             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToArray<int>(null, CancellationToken.None));
1022         }
1023 
1024         [TestMethod]
ToArray1()1025         public void ToArray1()
1026         {
1027             var xs = new[] { 42, 25, 39 };
1028             var res = xs.ToAsyncEnumerable().ToArray();
1029             Assert.IsTrue(res.Result.SequenceEqual(xs));
1030         }
1031 
1032         [TestMethod]
ToArray2()1033         public void ToArray2()
1034         {
1035             var xs = AsyncEnumerable.Empty<int>();
1036             var res = xs.ToArray();
1037             Assert.IsTrue(res.Result.Length == 0);
1038         }
1039 
1040         [TestMethod]
ToArray3()1041         public void ToArray3()
1042         {
1043             var ex = new Exception("Bang!");
1044             var res = AsyncEnumerable.Throw<int>(ex).ToArray();
1045             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
1046         }
1047 
1048         [TestMethod]
ToDictionary_Null()1049         public void ToDictionary_Null()
1050         {
1051             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0));
1052             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null));
1053 
1054             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default));
1055             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
1056             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null));
1057 
1058             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0));
1059             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
1060             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
1061 
1062             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
1063             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
1064             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
1065             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
1066 
1067             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, CancellationToken.None));
1068             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
1069 
1070             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1071             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
1072             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
1073 
1074             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
1075             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
1076             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
1077 
1078             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1079             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1080             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
1081             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToDictionary<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
1082         }
1083 
1084         [TestMethod]
ToDictionary1()1085         public void ToDictionary1()
1086         {
1087             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1088             var res = xs.ToDictionary(x => x % 2).Result;
1089             Assert.IsTrue(res[0] == 4);
1090             Assert.IsTrue(res[1] == 1);
1091         }
1092 
1093         [TestMethod]
ToDictionary2()1094         public void ToDictionary2()
1095         {
1096             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1097             AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
1098         }
1099 
1100         [TestMethod]
ToDictionary3()1101         public void ToDictionary3()
1102         {
1103             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1104             var res = xs.ToDictionary(x => x % 2, x => x + 1).Result;
1105             Assert.IsTrue(res[0] == 5);
1106             Assert.IsTrue(res[1] == 2);
1107         }
1108 
1109         [TestMethod]
ToDictionary4()1110         public void ToDictionary4()
1111         {
1112             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1113             AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, x => x + 1).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
1114         }
1115 
1116         [TestMethod]
ToDictionary5()1117         public void ToDictionary5()
1118         {
1119             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1120             var res = xs.ToDictionary(x => x % 2, new Eq()).Result;
1121             Assert.IsTrue(res[0] == 4);
1122             Assert.IsTrue(res[1] == 1);
1123         }
1124 
1125         [TestMethod]
ToDictionary6()1126         public void ToDictionary6()
1127         {
1128             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1129             AssertThrows<Exception>(() => xs.ToDictionary(x => x % 2, new Eq()).Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is ArgumentException);
1130         }
1131 
1132         [TestMethod]
ToDictionary7()1133         public void ToDictionary7()
1134         {
1135             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1136             var res = xs.ToDictionary(x => x % 2, x => x, new Eq()).Result;
1137             Assert.IsTrue(res[0] == 4);
1138             Assert.IsTrue(res[1] == 1);
1139         }
1140 
1141         [TestMethod]
ToLookup_Null()1142         public void ToLookup_Null()
1143         {
1144             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0));
1145             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null));
1146 
1147             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default));
1148             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
1149             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null));
1150 
1151             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0));
1152             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0));
1153             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null));
1154 
1155             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default));
1156             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default));
1157             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default));
1158             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null));
1159 
1160             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, CancellationToken.None));
1161             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
1162 
1163             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1164             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default, CancellationToken.None));
1165             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
1166 
1167             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, CancellationToken.None));
1168             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, CancellationToken.None));
1169             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, CancellationToken.None));
1170 
1171             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(null, x => 0, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1172             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), null, x => 0, EqualityComparer<int>.Default, CancellationToken.None));
1173             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, null, EqualityComparer<int>.Default, CancellationToken.None));
1174             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToLookup<int, int, int>(AsyncEnumerable.Return(42), x => 0, x => 0, null, CancellationToken.None));
1175         }
1176 
1177         [TestMethod]
ToLookup1()1178         public void ToLookup1()
1179         {
1180             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1181             var res = xs.ToLookup(x => x % 2).Result;
1182             Assert.IsTrue(res.Contains(0));
1183             Assert.IsTrue(res.Contains(1));
1184             Assert.IsTrue(res[0].Contains(4));
1185             Assert.IsTrue(res[1].Contains(1));
1186             Assert.IsTrue(res.Count == 2);
1187         }
1188 
1189         [TestMethod]
ToLookup2()1190         public void ToLookup2()
1191         {
1192             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1193             var res = xs.ToLookup(x => x % 2).Result;
1194             Assert.IsTrue(res.Contains(0));
1195             Assert.IsTrue(res.Contains(1));
1196             Assert.IsTrue(res[0].Contains(4));
1197             Assert.IsTrue(res[0].Contains(2));
1198             Assert.IsTrue(res[1].Contains(1));
1199             Assert.IsTrue(res.Count == 2);
1200         }
1201 
1202         [TestMethod]
ToLookup3()1203         public void ToLookup3()
1204         {
1205             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1206             var res = xs.ToLookup(x => x % 2, x => x + 1).Result;
1207             Assert.IsTrue(res.Contains(0));
1208             Assert.IsTrue(res.Contains(1));
1209             Assert.IsTrue(res[0].Contains(5));
1210             Assert.IsTrue(res[1].Contains(2));
1211             Assert.IsTrue(res.Count == 2);
1212         }
1213 
1214         [TestMethod]
ToLookup4()1215         public void ToLookup4()
1216         {
1217             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1218             var res = xs.ToLookup(x => x % 2, x => x + 1).Result;
1219             Assert.IsTrue(res.Contains(0));
1220             Assert.IsTrue(res.Contains(1));
1221             Assert.IsTrue(res[0].Contains(5));
1222             Assert.IsTrue(res[0].Contains(3));
1223             Assert.IsTrue(res[1].Contains(2));
1224             Assert.IsTrue(res.Count == 2);
1225         }
1226 
1227         [TestMethod]
ToLookup5()1228         public void ToLookup5()
1229         {
1230             var xs = new[] { 1, 4 }.ToAsyncEnumerable();
1231             var res = xs.ToLookup(x => x % 2, new Eq()).Result;
1232             Assert.IsTrue(res.Contains(0));
1233             Assert.IsTrue(res.Contains(1));
1234             Assert.IsTrue(res[0].Contains(4));
1235             Assert.IsTrue(res[1].Contains(1));
1236             Assert.IsTrue(res.Count == 2);
1237         }
1238 
1239         [TestMethod]
ToLookup6()1240         public void ToLookup6()
1241         {
1242             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1243             var res = xs.ToLookup(x => x % 2, new Eq()).Result;
1244             Assert.IsTrue(res.Contains(0));
1245             Assert.IsTrue(res.Contains(1));
1246             Assert.IsTrue(res[0].Contains(4));
1247             Assert.IsTrue(res[0].Contains(2));
1248             Assert.IsTrue(res[1].Contains(1));
1249             Assert.IsTrue(res.Count == 2);
1250         }
1251 
1252         [TestMethod]
ToLookup7()1253         public void ToLookup7()
1254         {
1255             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1256             var res = xs.ToLookup(x => x % 2).Result;
1257             foreach (var g in res)
1258                 Assert.IsTrue(g.Key == 0 || g.Key == 1);
1259         }
1260 
1261         [TestMethod]
ToLookup8()1262         public void ToLookup8()
1263         {
1264             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1265             var res = xs.ToLookup(x => x % 2).Result;
1266             foreach (IGrouping<int, int> g in (IEnumerable)res)
1267                 Assert.IsTrue(g.Key == 0 || g.Key == 1);
1268         }
1269 
1270         [TestMethod]
ToLookup9()1271         public void ToLookup9()
1272         {
1273             var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable();
1274             var res = xs.ToLookup(x => x % 2, x => x, new Eq()).Result;
1275             Assert.IsTrue(res.Contains(0));
1276             Assert.IsTrue(res.Contains(1));
1277             Assert.IsTrue(res[0].Contains(4));
1278             Assert.IsTrue(res[0].Contains(2));
1279             Assert.IsTrue(res[1].Contains(1));
1280             Assert.IsTrue(res.Count == 2);
1281         }
1282 
1283         [TestMethod]
Average_Null()1284         public void Average_Null()
1285         {
1286             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>)));
1287             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>)));
1288             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>)));
1289             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>)));
1290             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>)));
1291             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>)));
1292             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>)));
1293             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>)));
1294             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>)));
1295             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>)));
1296 
1297             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x));
1298             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x));
1299             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x));
1300             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x));
1301             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x));
1302             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x));
1303             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x));
1304             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x));
1305             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x));
1306             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x));
1307 
1308             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
1309             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
1310             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
1311             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
1312             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
1313             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
1314             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
1315             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
1316             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
1317             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
1318 
1319             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), CancellationToken.None));
1320             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), CancellationToken.None));
1321             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), CancellationToken.None));
1322             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), CancellationToken.None));
1323             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), CancellationToken.None));
1324             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), CancellationToken.None));
1325             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), CancellationToken.None));
1326             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), CancellationToken.None));
1327             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), CancellationToken.None));
1328             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
1329 
1330             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
1331             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
1332             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
1333             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
1334             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
1335             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
1336             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
1337             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
1338             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
1339             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
1340 
1341             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
1342             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
1343             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
1344             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
1345             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
1346             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
1347             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
1348             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
1349             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
1350             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Average(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
1351         }
1352 
1353         [TestMethod]
Average1()1354         public void Average1()
1355         {
1356             var xs = new[] { 1, 2, 3 };
1357             var ys = xs.ToAsyncEnumerable();
1358             Assert.AreEqual(xs.Average(), ys.Average().Result);
1359             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1360         }
1361 
1362         [TestMethod]
Average2()1363         public void Average2()
1364         {
1365             var xs = new[] { 1, default(int?), 3 };
1366             var ys = xs.ToAsyncEnumerable();
1367             Assert.AreEqual(xs.Average(), ys.Average().Result);
1368             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1369         }
1370 
1371         [TestMethod]
Average3()1372         public void Average3()
1373         {
1374             var xs = new[] { 1L, 2L, 3L };
1375             var ys = xs.ToAsyncEnumerable();
1376             Assert.AreEqual(xs.Average(), ys.Average().Result);
1377             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1378         }
1379 
1380         [TestMethod]
Average4()1381         public void Average4()
1382         {
1383             var xs = new[] { 1L, default(long?), 3L };
1384             var ys = xs.ToAsyncEnumerable();
1385             Assert.AreEqual(xs.Average(), ys.Average().Result);
1386             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1387         }
1388 
1389         [TestMethod]
Average5()1390         public void Average5()
1391         {
1392             var xs = new[] { 1.0, 2.0, 3.0 };
1393             var ys = xs.ToAsyncEnumerable();
1394             Assert.AreEqual(xs.Average(), ys.Average().Result);
1395             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1396         }
1397 
1398         [TestMethod]
Average6()1399         public void Average6()
1400         {
1401             var xs = new[] { 1.0, default(double?), 3.0 };
1402             var ys = xs.ToAsyncEnumerable();
1403             Assert.AreEqual(xs.Average(), ys.Average().Result);
1404             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1405         }
1406 
1407         [TestMethod]
Average7()1408         public void Average7()
1409         {
1410             var xs = new[] { 1.0f, 2.0f, 3.0f };
1411             var ys = xs.ToAsyncEnumerable();
1412             Assert.AreEqual(xs.Average(), ys.Average().Result);
1413             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1414         }
1415 
1416         [TestMethod]
Average8()1417         public void Average8()
1418         {
1419             var xs = new[] { 1.0f, default(float?), 3.0f };
1420             var ys = xs.ToAsyncEnumerable();
1421             Assert.AreEqual(xs.Average(), ys.Average().Result);
1422             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1423         }
1424 
1425         [TestMethod]
Average9()1426         public void Average9()
1427         {
1428             var xs = new[] { 1.0m, 2.0m, 3.0m };
1429             var ys = xs.ToAsyncEnumerable();
1430             Assert.AreEqual(xs.Average(), ys.Average().Result);
1431             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1432         }
1433 
1434         [TestMethod]
Average10()1435         public void Average10()
1436         {
1437             var xs = new[] { 1.0m, default(decimal?), 3.0m };
1438             var ys = xs.ToAsyncEnumerable();
1439             Assert.AreEqual(xs.Average(), ys.Average().Result);
1440             Assert.AreEqual(xs.Average(), ys.Average(x => x).Result);
1441         }
1442 
1443         [TestMethod]
Average11()1444         public void Average11()
1445         {
1446             var xs = new int[0];
1447             var ys = xs.ToAsyncEnumerable();
1448             AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
1449         }
1450 
1451         [TestMethod]
Average12()1452         public void Average12()
1453         {
1454             var xs = new int?[0];
1455             var ys = xs.ToAsyncEnumerable();
1456             Assert.IsNull(ys.Average().Result);
1457         }
1458 
1459         [TestMethod]
Average13()1460         public void Average13()
1461         {
1462             var xs = new long[0];
1463             var ys = xs.ToAsyncEnumerable();
1464             AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
1465         }
1466 
1467         [TestMethod]
Average14()1468         public void Average14()
1469         {
1470             var xs = new long?[0];
1471             var ys = xs.ToAsyncEnumerable();
1472             Assert.IsNull(ys.Average().Result);
1473         }
1474 
1475         [TestMethod]
Average15()1476         public void Average15()
1477         {
1478             var xs = new double[0];
1479             var ys = xs.ToAsyncEnumerable();
1480             AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
1481         }
1482 
1483         [TestMethod]
Average16()1484         public void Average16()
1485         {
1486             var xs = new double?[0];
1487             var ys = xs.ToAsyncEnumerable();
1488             Assert.IsNull(ys.Average().Result);
1489         }
1490 
1491         [TestMethod]
Average17()1492         public void Average17()
1493         {
1494             var xs = new float[0];
1495             var ys = xs.ToAsyncEnumerable();
1496             AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
1497         }
1498 
1499         [TestMethod]
Average18()1500         public void Average18()
1501         {
1502             var xs = new float?[0];
1503             var ys = xs.ToAsyncEnumerable();
1504             Assert.IsNull(ys.Average().Result);
1505         }
1506 
1507         [TestMethod]
Average19()1508         public void Average19()
1509         {
1510             var xs = new decimal[0];
1511             var ys = xs.ToAsyncEnumerable();
1512             AssertThrows<Exception>(() => ys.Average().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
1513         }
1514 
1515         [TestMethod]
Average20()1516         public void Average20()
1517         {
1518             var xs = new decimal?[0];
1519             var ys = xs.ToAsyncEnumerable();
1520             Assert.IsNull(ys.Average().Result);
1521         }
1522 
1523         [TestMethod]
Min_Null()1524         public void Min_Null()
1525         {
1526             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>)));
1527             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>)));
1528             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>)));
1529             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>)));
1530             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>)));
1531             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>)));
1532             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>)));
1533             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>)));
1534             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>)));
1535             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>)));
1536 
1537             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x));
1538             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x));
1539             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x));
1540             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x));
1541             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x));
1542             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x));
1543             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x));
1544             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x));
1545             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x));
1546             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x));
1547 
1548             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
1549             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
1550             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
1551             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
1552             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
1553             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
1554             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
1555             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
1556             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
1557             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
1558 
1559             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>)));
1560             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x));
1561             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
1562 
1563             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), CancellationToken.None));
1564             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), CancellationToken.None));
1565             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), CancellationToken.None));
1566             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), CancellationToken.None));
1567             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), CancellationToken.None));
1568             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), CancellationToken.None));
1569             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), CancellationToken.None));
1570             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), CancellationToken.None));
1571             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), CancellationToken.None));
1572             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
1573 
1574             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
1575             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
1576             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
1577             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
1578             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
1579             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
1580             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
1581             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
1582             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
1583             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
1584 
1585             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
1586             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
1587             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
1588             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
1589             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
1590             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
1591             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
1592             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
1593             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
1594             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
1595 
1596             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
1597             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
1598             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
1599 
1600             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
1601             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
1602 
1603             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
1604             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Min(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
1605         }
1606 
1607         [TestMethod]
Min1()1608         public void Min1()
1609         {
1610             var xs = new[] { 2, 1, 3 };
1611             var ys = xs.ToAsyncEnumerable();
1612             Assert.AreEqual(xs.Min(), ys.Min().Result);
1613             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1614         }
1615 
1616         [TestMethod]
Min2()1617         public void Min2()
1618         {
1619             var xs = new[] { 2, default(int?), 3 };
1620             var ys = xs.ToAsyncEnumerable();
1621             Assert.AreEqual(xs.Min(), ys.Min().Result);
1622             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1623         }
1624 
1625         [TestMethod]
Min3()1626         public void Min3()
1627         {
1628             var xs = new[] { 2L, 1L, 3L };
1629             var ys = xs.ToAsyncEnumerable();
1630             Assert.AreEqual(xs.Min(), ys.Min().Result);
1631             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1632         }
1633 
1634         [TestMethod]
Min4()1635         public void Min4()
1636         {
1637             var xs = new[] { 2L, default(long?), 3L };
1638             var ys = xs.ToAsyncEnumerable();
1639             Assert.AreEqual(xs.Min(), ys.Min().Result);
1640             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1641         }
1642 
1643         [TestMethod]
Min5()1644         public void Min5()
1645         {
1646             var xs = new[] { 2.0, 1.0, 3.0 };
1647             var ys = xs.ToAsyncEnumerable();
1648             Assert.AreEqual(xs.Min(), ys.Min().Result);
1649             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1650         }
1651 
1652         [TestMethod]
Min6()1653         public void Min6()
1654         {
1655             var xs = new[] { 2.0, default(double?), 3.0 };
1656             var ys = xs.ToAsyncEnumerable();
1657             Assert.AreEqual(xs.Min(), ys.Min().Result);
1658             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1659         }
1660 
1661         [TestMethod]
Min7()1662         public void Min7()
1663         {
1664             var xs = new[] { 2.0f, 1.0f, 3.0f };
1665             var ys = xs.ToAsyncEnumerable();
1666             Assert.AreEqual(xs.Min(), ys.Min().Result);
1667             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1668         }
1669 
1670         [TestMethod]
Min8()1671         public void Min8()
1672         {
1673             var xs = new[] { 2.0f, default(float?), 3.0f };
1674             var ys = xs.ToAsyncEnumerable();
1675             Assert.AreEqual(xs.Min(), ys.Min().Result);
1676             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1677         }
1678 
1679         [TestMethod]
Min9()1680         public void Min9()
1681         {
1682             var xs = new[] { 2.0m, 1.0m, 3.0m };
1683             var ys = xs.ToAsyncEnumerable();
1684             Assert.AreEqual(xs.Min(), ys.Min().Result);
1685             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1686         }
1687 
1688         [TestMethod]
Min10()1689         public void Min10()
1690         {
1691             var xs = new[] { 2.0m, default(decimal?), 3.0m };
1692             var ys = xs.ToAsyncEnumerable();
1693             Assert.AreEqual(xs.Min(), ys.Min().Result);
1694             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1695         }
1696 
1697         [TestMethod]
Min11()1698         public void Min11()
1699         {
1700             var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now };
1701             var ys = xs.ToAsyncEnumerable();
1702             Assert.AreEqual(xs.Min(), ys.Min().Result);
1703             Assert.AreEqual(xs.Min(), ys.Min(x => x).Result);
1704         }
1705 
1706         [TestMethod]
Max_Null()1707         public void Max_Null()
1708         {
1709             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>)));
1710             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>)));
1711             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>)));
1712             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>)));
1713             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>)));
1714             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>)));
1715             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>)));
1716             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>)));
1717             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>)));
1718             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>)));
1719 
1720             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x));
1721             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x));
1722             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x));
1723             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x));
1724             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x));
1725             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x));
1726             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x));
1727             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x));
1728             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x));
1729             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x));
1730 
1731             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
1732             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
1733             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
1734             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
1735             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
1736             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
1737             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
1738             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
1739             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
1740             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
1741 
1742             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>)));
1743             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x));
1744             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>)));
1745 
1746             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), CancellationToken.None));
1747             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), CancellationToken.None));
1748             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), CancellationToken.None));
1749             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), CancellationToken.None));
1750             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), CancellationToken.None));
1751             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), CancellationToken.None));
1752             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), CancellationToken.None));
1753             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), CancellationToken.None));
1754             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), CancellationToken.None));
1755             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
1756 
1757             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
1758             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
1759             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
1760             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
1761             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
1762             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
1763             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
1764             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
1765             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
1766             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
1767 
1768             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
1769             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
1770             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
1771             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
1772             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
1773             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
1774             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
1775             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
1776             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
1777             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
1778 
1779             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), CancellationToken.None));
1780             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), x => x, CancellationToken.None));
1781             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, bool>), CancellationToken.None));
1782 
1783             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default));
1784             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>)));
1785 
1786             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(default(IAsyncEnumerable<DateTime>), Comparer<DateTime>.Default, CancellationToken.None));
1787             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Max(AsyncEnumerable.Empty<DateTime>(), default(IComparer<DateTime>), CancellationToken.None));
1788         }
1789 
1790         [TestMethod]
Max1()1791         public void Max1()
1792         {
1793             var xs = new[] { 2, 7, 3 };
1794             var ys = xs.ToAsyncEnumerable();
1795             Assert.AreEqual(xs.Max(), ys.Max().Result);
1796             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1797         }
1798 
1799         [TestMethod]
Max2()1800         public void Max2()
1801         {
1802             var xs = new[] { 2, default(int?), 3, 1 };
1803             var ys = xs.ToAsyncEnumerable();
1804             Assert.AreEqual(xs.Max(), ys.Max().Result);
1805             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1806         }
1807 
1808         [TestMethod]
Max3()1809         public void Max3()
1810         {
1811             var xs = new[] { 2L, 7L, 3L };
1812             var ys = xs.ToAsyncEnumerable();
1813             Assert.AreEqual(xs.Max(), ys.Max().Result);
1814             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1815         }
1816 
1817         [TestMethod]
Max4()1818         public void Max4()
1819         {
1820             var xs = new[] { 2L, default(long?), 3L, 1L };
1821             var ys = xs.ToAsyncEnumerable();
1822             Assert.AreEqual(xs.Max(), ys.Max().Result);
1823             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1824         }
1825 
1826         [TestMethod]
Max5()1827         public void Max5()
1828         {
1829             var xs = new[] { 2.0, 7.0, 3.0 };
1830             var ys = xs.ToAsyncEnumerable();
1831             Assert.AreEqual(xs.Max(), ys.Max().Result);
1832             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1833         }
1834 
1835         [TestMethod]
Max6()1836         public void Max6()
1837         {
1838             var xs = new[] { 2.0, default(double?), 3.0, 1.0 };
1839             var ys = xs.ToAsyncEnumerable();
1840             Assert.AreEqual(xs.Max(), ys.Max().Result);
1841             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1842         }
1843 
1844         [TestMethod]
Max7()1845         public void Max7()
1846         {
1847             var xs = new[] { 2.0f, 7.0f, 3.0f };
1848             var ys = xs.ToAsyncEnumerable();
1849             Assert.AreEqual(xs.Max(), ys.Max().Result);
1850             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1851         }
1852 
1853         [TestMethod]
Max8()1854         public void Max8()
1855         {
1856             var xs = new[] { 2.0f, default(float?), 3.0f, 1.0f };
1857             var ys = xs.ToAsyncEnumerable();
1858             Assert.AreEqual(xs.Max(), ys.Max().Result);
1859             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1860         }
1861 
1862         [TestMethod]
Max9()1863         public void Max9()
1864         {
1865             var xs = new[] { 2.0m, 7.0m, 3.0m };
1866             var ys = xs.ToAsyncEnumerable();
1867             Assert.AreEqual(xs.Max(), ys.Max().Result);
1868             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1869         }
1870 
1871         [TestMethod]
Max10()1872         public void Max10()
1873         {
1874             var xs = new[] { 2.0m, default(decimal?), 3.0m, 1.0m };
1875             var ys = xs.ToAsyncEnumerable();
1876             Assert.AreEqual(xs.Max(), ys.Max().Result);
1877             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1878         }
1879 
1880         [TestMethod]
Max11()1881         public void Max11()
1882         {
1883             var xs = new[] { DateTime.Now.AddDays(1), DateTime.Now.Subtract(TimeSpan.FromDays(1)), DateTime.Now.AddDays(2), DateTime.Now };
1884             var ys = xs.ToAsyncEnumerable();
1885             Assert.AreEqual(xs.Max(), ys.Max().Result);
1886             Assert.AreEqual(xs.Max(), ys.Max(x => x).Result);
1887         }
1888 
1889         [TestMethod]
Sum_Null()1890         public void Sum_Null()
1891         {
1892             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>)));
1893             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>)));
1894             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>)));
1895             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>)));
1896             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>)));
1897             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>)));
1898             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>)));
1899             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>)));
1900             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>)));
1901             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>)));
1902 
1903             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x));
1904             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x));
1905             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x));
1906             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x));
1907             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x));
1908             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x));
1909             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x));
1910             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x));
1911             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x));
1912             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x));
1913 
1914             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>)));
1915             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>)));
1916             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>)));
1917             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>)));
1918             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>)));
1919             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>)));
1920             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>)));
1921             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>)));
1922             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>)));
1923             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>)));
1924 
1925             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), CancellationToken.None));
1926             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), CancellationToken.None));
1927             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), CancellationToken.None));
1928             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), CancellationToken.None));
1929             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), CancellationToken.None));
1930             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), CancellationToken.None));
1931             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), CancellationToken.None));
1932             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), CancellationToken.None));
1933             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), CancellationToken.None));
1934             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), CancellationToken.None));
1935 
1936             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
1937             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<int?>), x => x, CancellationToken.None));
1938             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long>), x => x, CancellationToken.None));
1939             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<long?>), x => x, CancellationToken.None));
1940             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double>), x => x, CancellationToken.None));
1941             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<double?>), x => x, CancellationToken.None));
1942             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float>), x => x, CancellationToken.None));
1943             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<float?>), x => x, CancellationToken.None));
1944             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None));
1945             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None));
1946 
1947             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None));
1948             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None));
1949             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None));
1950             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None));
1951             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double>), CancellationToken.None));
1952             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, double?>), CancellationToken.None));
1953             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float>), CancellationToken.None));
1954             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, float?>), CancellationToken.None));
1955             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal>), CancellationToken.None));
1956             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Sum(AsyncEnumerable.Empty<int>(), default(Func<int, decimal?>), CancellationToken.None));
1957         }
1958 
1959         [TestMethod]
Sum1()1960         public void Sum1()
1961         {
1962             var xs = new[] { 1, 2, 3 };
1963             var ys = xs.ToAsyncEnumerable();
1964             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
1965             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
1966         }
1967 
1968         [TestMethod]
Sum2()1969         public void Sum2()
1970         {
1971             var xs = new[] { 1, default(int?), 3 };
1972             var ys = xs.ToAsyncEnumerable();
1973             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
1974             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
1975         }
1976 
1977         [TestMethod]
Sum3()1978         public void Sum3()
1979         {
1980             var xs = new[] { 1L, 2L, 3L };
1981             var ys = xs.ToAsyncEnumerable();
1982             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
1983             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
1984         }
1985 
1986         [TestMethod]
Sum4()1987         public void Sum4()
1988         {
1989             var xs = new[] { 1L, default(long?), 3L };
1990             var ys = xs.ToAsyncEnumerable();
1991             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
1992             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
1993         }
1994 
1995         [TestMethod]
Sum5()1996         public void Sum5()
1997         {
1998             var xs = new[] { 1.0, 2.0, 3.0 };
1999             var ys = xs.ToAsyncEnumerable();
2000             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2001             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2002         }
2003 
2004         [TestMethod]
Sum6()2005         public void Sum6()
2006         {
2007             var xs = new[] { 1.0, default(double?), 3.0 };
2008             var ys = xs.ToAsyncEnumerable();
2009             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2010             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2011         }
2012 
2013         [TestMethod]
Sum7()2014         public void Sum7()
2015         {
2016             var xs = new[] { 1.0f, 2.0f, 3.0f };
2017             var ys = xs.ToAsyncEnumerable();
2018             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2019             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2020         }
2021 
2022         [TestMethod]
Sum8()2023         public void Sum8()
2024         {
2025             var xs = new[] { 1.0f, default(float?), 3.0f };
2026             var ys = xs.ToAsyncEnumerable();
2027             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2028             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2029         }
2030 
2031         [TestMethod]
Sum9()2032         public void Sum9()
2033         {
2034             var xs = new[] { 1.0m, 2.0m, 3.0m };
2035             var ys = xs.ToAsyncEnumerable();
2036             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2037             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2038         }
2039 
2040         [TestMethod]
Sum10()2041         public void Sum10()
2042         {
2043             var xs = new[] { 1.0m, default(decimal?), 3.0m };
2044             var ys = xs.ToAsyncEnumerable();
2045             Assert.AreEqual(xs.Sum(), ys.Sum().Result);
2046             Assert.AreEqual(xs.Sum(), ys.Sum(x => x).Result);
2047         }
2048 
2049         [TestMethod]
MinBy_Null()2050         public void MinBy_Null()
2051         {
2052             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x));
2053             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
2054 
2055             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
2056             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
2057             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
2058 
2059             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
2060             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
2061 
2062             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
2063             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
2064             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MinBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
2065         }
2066 
2067         [TestMethod]
MinBy1()2068         public void MinBy1()
2069         {
2070             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => x / 2);
2071             var res = xs.Result;
2072 
2073             Assert.IsTrue(res.SequenceEqual(new[] { 3, 2 }));
2074         }
2075 
2076         [TestMethod]
MinBy2()2077         public void MinBy2()
2078         {
2079             var xs = new int[0].ToAsyncEnumerable().MinBy(x => x / 2);
2080 
2081             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
2082         }
2083 
2084         [TestMethod]
MinBy3()2085         public void MinBy3()
2086         {
2087             var ex = new Exception("Bang!");
2088             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 3) throw ex; return x; });
2089 
2090             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2091         }
2092 
2093         [TestMethod]
MinBy4()2094         public void MinBy4()
2095         {
2096             var ex = new Exception("Bang!");
2097             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinBy(x => { if (x == 4) throw ex; return x; });
2098 
2099             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2100         }
2101 
2102         [TestMethod]
MinBy5()2103         public void MinBy5()
2104         {
2105             var ex = new Exception("Bang!");
2106             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex)).MinBy(x => x, Comparer<int>.Default);
2107 
2108             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2109         }
2110 
2111         [TestMethod]
MaxBy_Null()2112         public void MaxBy_Null()
2113         {
2114             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x));
2115             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>)));
2116 
2117             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default));
2118             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default));
2119             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>)));
2120 
2121             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, CancellationToken.None));
2122             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), CancellationToken.None));
2123 
2124             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(default(IAsyncEnumerable<int>), x => x, Comparer<int>.Default, CancellationToken.None));
2125             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), default(Func<int, int>), Comparer<int>.Default, CancellationToken.None));
2126             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.MaxBy(AsyncEnumerable.Return(42), x => x, default(IComparer<int>), CancellationToken.None));
2127         }
2128 
2129         [TestMethod]
MaxBy1()2130         public void MaxBy1()
2131         {
2132             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => x / 2);
2133             var res = xs.Result;
2134 
2135             Assert.IsTrue(res.SequenceEqual(new[] { 7, 6 }));
2136         }
2137 
2138         [TestMethod]
MaxBy2()2139         public void MaxBy2()
2140         {
2141             var xs = new int[0].ToAsyncEnumerable().MaxBy(x => x / 2);
2142 
2143             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is InvalidOperationException);
2144         }
2145 
2146         [TestMethod]
MaxBy3()2147         public void MaxBy3()
2148         {
2149             var ex = new Exception("Bang!");
2150             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 3) throw ex; return x; });
2151 
2152             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2153         }
2154 
2155         [TestMethod]
MaxBy4()2156         public void MaxBy4()
2157         {
2158             var ex = new Exception("Bang!");
2159             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxBy(x => { if (x == 4) throw ex; return x; });
2160 
2161             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2162         }
2163 
2164         [TestMethod]
MaxBy5()2165         public void MaxBy5()
2166         {
2167             var ex = new Exception("Bang!");
2168             var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex)).MaxBy(x => x, Comparer<int>.Default);
2169 
2170             AssertThrows<Exception>(() => xs.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
2171         }
2172     }
2173 }
2174 
2175 #endif