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