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