AsyncTests.Single.cs 86 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479
  1. // Licensed to the .NET Foundation under one or more agreements.
  2. // The .NET Foundation licenses this file to you under the Apache 2.0 License.
  3. // See the LICENSE file in the project root for more information.
  4. using System;
  5. using System.Collections.Generic;
  6. using System.Linq;
  7. using System.Text;
  8. using Xunit;
  9. using System.Threading;
  10. using System.Threading.Tasks;
  11. namespace Tests
  12. {
  13. public partial class AsyncTests
  14. {
  15. [Fact]
  16. public void Select_Null()
  17. {
  18. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(null, x => x));
  19. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(null, (x, i) => x));
  20. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(AsyncEnumerable.Return<int>(42), default(Func<int, int>)));
  21. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(AsyncEnumerable.Return<int>(42), default(Func<int, int, int>)));
  22. }
  23. [Fact]
  24. public void Select1()
  25. {
  26. var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
  27. var ys = xs.Select(x => (char)('a' + x));
  28. var e = ys.GetEnumerator();
  29. HasNext(e, 'a');
  30. HasNext(e, 'b');
  31. HasNext(e, 'c');
  32. NoNext(e);
  33. }
  34. [Fact]
  35. public void Select2()
  36. {
  37. var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
  38. var ys = xs.Select((x, i) => (char)('a' + i));
  39. var e = ys.GetEnumerator();
  40. HasNext(e, 'a');
  41. HasNext(e, 'b');
  42. HasNext(e, 'c');
  43. NoNext(e);
  44. }
  45. [Fact]
  46. public void Select3()
  47. {
  48. var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
  49. var ys = xs.Select(x => 1 / x);
  50. var e = ys.GetEnumerator();
  51. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
  52. }
  53. [Fact]
  54. public void Select4()
  55. {
  56. var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
  57. var ys = xs.Select((x, i) => 1 / i);
  58. var e = ys.GetEnumerator();
  59. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is DivideByZeroException);
  60. }
  61. [Fact]
  62. public void Where_Null()
  63. {
  64. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(null, x => true));
  65. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(null, (x, i) => true));
  66. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(AsyncEnumerable.Return<int>(42), default(Func<int, bool>)));
  67. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Where<int>(AsyncEnumerable.Return<int>(42), default(Func<int, int, bool>)));
  68. }
  69. [Fact]
  70. public void Where1()
  71. {
  72. var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
  73. var ys = xs.Where(x => x % 2 == 0);
  74. var e = ys.GetEnumerator();
  75. HasNext(e, 8);
  76. HasNext(e, 4);
  77. HasNext(e, 6);
  78. HasNext(e, 2);
  79. HasNext(e, 0);
  80. NoNext(e);
  81. }
  82. [Fact]
  83. public void Where2()
  84. {
  85. var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
  86. var ys = xs.Where((x, i) => i % 2 == 0);
  87. var e = ys.GetEnumerator();
  88. HasNext(e, 8);
  89. HasNext(e, 7);
  90. HasNext(e, 6);
  91. HasNext(e, 2);
  92. HasNext(e, 0);
  93. NoNext(e);
  94. }
  95. [Fact]
  96. public void Where3()
  97. {
  98. var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
  99. var ex = new Exception("Bang");
  100. var ys = xs.Where(x => { if (x == 4) throw ex; return true; });
  101. var e = ys.GetEnumerator();
  102. HasNext(e, 8);
  103. HasNext(e, 5);
  104. HasNext(e, 7);
  105. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  106. }
  107. [Fact]
  108. public void Where4()
  109. {
  110. var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
  111. var ex = new Exception("Bang");
  112. var ys = xs.Where((x, i) => { if (i == 3) throw ex; return true; });
  113. var e = ys.GetEnumerator();
  114. HasNext(e, 8);
  115. HasNext(e, 5);
  116. HasNext(e, 7);
  117. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  118. }
  119. [Fact]
  120. public void Where5()
  121. {
  122. var ex = new Exception("Bang");
  123. var xs = AsyncEnumerable.Throw<int>(ex);
  124. var ys = xs.Where(x => true);
  125. var e = ys.GetEnumerator();
  126. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  127. }
  128. [Fact]
  129. public void Where6()
  130. {
  131. var ex = new Exception("Bang");
  132. var xs = AsyncEnumerable.Throw<int>(ex);
  133. var ys = xs.Where((x, i) => true);
  134. var e = ys.GetEnumerator();
  135. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  136. }
  137. [Fact]
  138. public void SelectMany_Null()
  139. {
  140. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(null, x => null));
  141. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(null, (x, i) => null));
  142. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(AsyncEnumerable.Return(42), default(Func<int, IAsyncEnumerable<int>>)));
  143. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(AsyncEnumerable.Return(42), default(Func<int, int, IAsyncEnumerable<int>>)));
  144. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(null, x => null, (x, y) => x));
  145. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(null, (x, i) => null, (x, y) => x));
  146. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, IAsyncEnumerable<int>>), (x, y) => x));
  147. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int, IAsyncEnumerable<int>>), (x, y) => x));
  148. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(AsyncEnumerable.Return(42), x => null, default(Func<int, int, int>)));
  149. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int, int>(AsyncEnumerable.Return(42), (x, i) => null, default(Func<int, int, int>)));
  150. }
  151. [Fact]
  152. public void SelectMany1()
  153. {
  154. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  155. var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable());
  156. var e = ys.GetEnumerator();
  157. HasNext(e, 0);
  158. HasNext(e, 0);
  159. HasNext(e, 1);
  160. HasNext(e, 0);
  161. HasNext(e, 1);
  162. HasNext(e, 2);
  163. NoNext(e);
  164. }
  165. [Fact]
  166. public void SelectMany2()
  167. {
  168. var ex = new Exception("Bang");
  169. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  170. var ys = xs.SelectMany(x =>
  171. {
  172. if (x < 3)
  173. return Enumerable.Range(0, x).ToAsyncEnumerable();
  174. else
  175. return AsyncEnumerable.Throw<int>(ex);
  176. });
  177. var e = ys.GetEnumerator();
  178. HasNext(e, 0);
  179. HasNext(e, 0);
  180. HasNext(e, 1);
  181. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  182. }
  183. [Fact]
  184. public void SelectMany3()
  185. {
  186. var ex = new Exception("Bang");
  187. var xs = AsyncEnumerable.Throw<int>(ex);
  188. var ys = xs.SelectMany(x => Enumerable.Range(0, x).ToAsyncEnumerable());
  189. var e = ys.GetEnumerator();
  190. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  191. }
  192. [Fact]
  193. public void SelectMany4()
  194. {
  195. var ex = new Exception("Bang");
  196. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  197. var ys = xs.SelectMany(x =>
  198. {
  199. if (x < 3)
  200. return Enumerable.Range(0, x).ToAsyncEnumerable();
  201. else
  202. throw ex;
  203. });
  204. var e = ys.GetEnumerator();
  205. HasNext(e, 0);
  206. HasNext(e, 0);
  207. HasNext(e, 1);
  208. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  209. }
  210. [Fact]
  211. public void SelectMany5()
  212. {
  213. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  214. var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 5, x).ToAsyncEnumerable());
  215. var e = ys.GetEnumerator();
  216. HasNext(e, 5);
  217. HasNext(e, 6);
  218. HasNext(e, 7);
  219. HasNext(e, 7);
  220. HasNext(e, 8);
  221. HasNext(e, 9);
  222. NoNext(e);
  223. }
  224. [Fact]
  225. public void SelectMany6()
  226. {
  227. var ex = new Exception("Bang");
  228. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  229. var ys = xs.SelectMany((x, i) =>
  230. {
  231. if (i < 2)
  232. return Enumerable.Range(0, x).ToAsyncEnumerable();
  233. else
  234. return AsyncEnumerable.Throw<int>(ex);
  235. });
  236. var e = ys.GetEnumerator();
  237. HasNext(e, 0);
  238. HasNext(e, 0);
  239. HasNext(e, 1);
  240. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  241. }
  242. [Fact]
  243. public void SelectMany7()
  244. {
  245. var ex = new Exception("Bang");
  246. var xs = AsyncEnumerable.Throw<int>(ex);
  247. var ys = xs.SelectMany((x, i) => Enumerable.Range(0, x).ToAsyncEnumerable());
  248. var e = ys.GetEnumerator();
  249. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  250. }
  251. [Fact]
  252. public void SelectMany8()
  253. {
  254. var ex = new Exception("Bang");
  255. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  256. var ys = xs.SelectMany((x, i) =>
  257. {
  258. if (i < 2)
  259. return Enumerable.Range(0, x).ToAsyncEnumerable();
  260. else
  261. throw ex;
  262. });
  263. var e = ys.GetEnumerator();
  264. HasNext(e, 0);
  265. HasNext(e, 0);
  266. HasNext(e, 1);
  267. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  268. }
  269. [Fact]
  270. public void SelectMany9()
  271. {
  272. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  273. var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) => x * y);
  274. var e = ys.GetEnumerator();
  275. HasNext(e, 3);
  276. HasNext(e, 6);
  277. HasNext(e, 8);
  278. HasNext(e, 9);
  279. HasNext(e, 12);
  280. HasNext(e, 15);
  281. NoNext(e);
  282. }
  283. [Fact]
  284. public void SelectMany10()
  285. {
  286. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  287. var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) => x * y);
  288. var e = ys.GetEnumerator();
  289. HasNext(e, 3);
  290. HasNext(e, 8);
  291. HasNext(e, 10);
  292. HasNext(e, 15);
  293. HasNext(e, 18);
  294. HasNext(e, 21);
  295. NoNext(e);
  296. }
  297. [Fact]
  298. public void SelectMany11()
  299. {
  300. var ex = new Exception("Bang");
  301. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  302. var ys = xs.SelectMany(x => Enumerable.Range(3, x).ToAsyncEnumerable(), (x, y) =>
  303. {
  304. if (x * y > 10)
  305. throw ex;
  306. return x * y;
  307. });
  308. var e = ys.GetEnumerator();
  309. HasNext(e, 3);
  310. HasNext(e, 6);
  311. HasNext(e, 8);
  312. HasNext(e, 9);
  313. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  314. }
  315. [Fact]
  316. public void SelectMany12()
  317. {
  318. var ex = new Exception("Bang");
  319. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  320. var ys = xs.SelectMany((x, i) => Enumerable.Range(i + 3, x).ToAsyncEnumerable(), (x, y) =>
  321. {
  322. if (x * y > 10)
  323. throw ex;
  324. return x * y;
  325. });
  326. var e = ys.GetEnumerator();
  327. HasNext(e, 3);
  328. HasNext(e, 8);
  329. HasNext(e, 10);
  330. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  331. }
  332. [Fact]
  333. public void OfType_Null()
  334. {
  335. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OfType<int>(null));
  336. }
  337. [Fact]
  338. public void OfType()
  339. {
  340. var xs = new object[] { 1, 1.2, true, 4, "" }.ToAsyncEnumerable();
  341. var ys = xs.OfType<int>();
  342. var e = ys.GetEnumerator();
  343. HasNext(e, 1);
  344. HasNext(e, 4);
  345. NoNext(e);
  346. }
  347. [Fact]
  348. public void Cast_Null()
  349. {
  350. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Cast<int>(null));
  351. }
  352. [Fact]
  353. public void Cast()
  354. {
  355. var xs = new object[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  356. var ys = xs.Cast<int>();
  357. var e = ys.GetEnumerator();
  358. HasNext(e, 1);
  359. HasNext(e, 2);
  360. HasNext(e, 3);
  361. HasNext(e, 4);
  362. NoNext(e);
  363. }
  364. [Fact]
  365. public void Do_Null()
  366. {
  367. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(null, x => { }));
  368. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), default(Action<int>)));
  369. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(null, x => { }, () => { }));
  370. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), default(Action<int>), () => { }));
  371. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), x => { }, default(Action)));
  372. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(null, x => { }, ex => { }));
  373. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), default(Action<int>), ex => { }));
  374. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), x => { }, default(Action<Exception>)));
  375. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(null, x => { }, ex => { }, () => { }));
  376. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), default(Action<int>), ex => { }, () => { }));
  377. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), x => { }, default(Action<Exception>), () => { }));
  378. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), x => { }, ex => { }, default(Action)));
  379. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(null, new MyObs()));
  380. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Do<int>(AsyncEnumerable.Return(42), default(IObserver<int>)));
  381. }
  382. class MyObs : IObserver<int>
  383. {
  384. public void OnCompleted()
  385. {
  386. throw new NotImplementedException();
  387. }
  388. public void OnError(Exception error)
  389. {
  390. throw new NotImplementedException();
  391. }
  392. public void OnNext(int value)
  393. {
  394. throw new NotImplementedException();
  395. }
  396. }
  397. [Fact]
  398. public void Do1()
  399. {
  400. var sum = 0;
  401. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  402. var ys = xs.Do(x => sum += x);
  403. var e = ys.GetEnumerator();
  404. HasNext(e, 1);
  405. Assert.Equal(1, sum);
  406. HasNext(e, 2);
  407. Assert.Equal(3, sum);
  408. HasNext(e, 3);
  409. Assert.Equal(6, sum);
  410. HasNext(e, 4);
  411. Assert.Equal(10, sum);
  412. NoNext(e);
  413. }
  414. [Fact]
  415. public void Do2()
  416. {
  417. var ex = new Exception("Bang");
  418. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  419. var ys = xs.Do(x => { throw ex; });
  420. var e = ys.GetEnumerator();
  421. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  422. }
  423. [Fact]
  424. public void Do3()
  425. {
  426. var sum = 0;
  427. var fail = false;
  428. var done = false;
  429. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  430. var ys = xs.Do(x => sum += x, ex => { fail = true; }, () => { done = true; });
  431. var e = ys.GetEnumerator();
  432. HasNext(e, 1);
  433. Assert.Equal(1, sum);
  434. HasNext(e, 2);
  435. Assert.Equal(3, sum);
  436. HasNext(e, 3);
  437. Assert.Equal(6, sum);
  438. HasNext(e, 4);
  439. Assert.Equal(10, sum);
  440. NoNext(e);
  441. Assert.False(fail);
  442. Assert.True(done);
  443. }
  444. [Fact]
  445. public void Do4()
  446. {
  447. var sum = 0;
  448. var done = false;
  449. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  450. var ys = xs.Do(x => sum += x, () => { done = true; });
  451. var e = ys.GetEnumerator();
  452. HasNext(e, 1);
  453. Assert.Equal(1, sum);
  454. HasNext(e, 2);
  455. Assert.Equal(3, sum);
  456. HasNext(e, 3);
  457. Assert.Equal(6, sum);
  458. HasNext(e, 4);
  459. Assert.Equal(10, sum);
  460. NoNext(e);
  461. Assert.True(done);
  462. }
  463. [Fact]
  464. public void Do5()
  465. {
  466. var ex = new Exception("Bang");
  467. var exa = default(Exception);
  468. var done = false;
  469. var hasv = false;
  470. var xs = AsyncEnumerable.Throw<int>(ex);
  471. var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; }, () => { done = true; });
  472. var e = ys.GetEnumerator();
  473. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ex_.InnerException == ex);
  474. Assert.False(hasv);
  475. Assert.False(done);
  476. Assert.Same(exa, ex);
  477. }
  478. [Fact]
  479. public void Do6()
  480. {
  481. var ex = new Exception("Bang");
  482. var exa = default(Exception);
  483. var hasv = false;
  484. var xs = AsyncEnumerable.Throw<int>(ex);
  485. var ys = xs.Do(x => { hasv = true; }, exx => { exa = exx; });
  486. var e = ys.GetEnumerator();
  487. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ex_.InnerException == ex);
  488. Assert.False(hasv);
  489. Assert.Same(exa, ex);
  490. }
  491. [Fact]
  492. public async Task ForEachAsync_Null()
  493. {
  494. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }));
  495. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>)));
  496. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }));
  497. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>)));
  498. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, x => { }, CancellationToken.None));
  499. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int>), CancellationToken.None));
  500. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(null, (x, i) => { }, CancellationToken.None));
  501. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(AsyncEnumerable.Return(42), default(Action<int, int>), CancellationToken.None));
  502. }
  503. [Fact]
  504. public void ForEach_Null()
  505. {
  506. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(null, x => { }));
  507. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(AsyncEnumerable.Return(42), default(Action<int>)));
  508. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(null, (x, i) => { }));
  509. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(AsyncEnumerable.Return(42), default(Action<int, int>)));
  510. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(null, x => { }, CancellationToken.None));
  511. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(AsyncEnumerable.Return(42), default(Action<int>), CancellationToken.None));
  512. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(null, (x, i) => { }, CancellationToken.None));
  513. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ForEach<int>(AsyncEnumerable.Return(42), default(Action<int, int>), CancellationToken.None));
  514. }
  515. [Fact]
  516. public void ForEachAsync1()
  517. {
  518. var sum = 0;
  519. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  520. xs.ForEachAsync(x => sum += x).Wait(WaitTimeoutMs);
  521. Assert.Equal(10, sum);
  522. }
  523. [Fact]
  524. public void ForEach1()
  525. {
  526. var sum = 0;
  527. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  528. xs.ForEach(x => sum += x);
  529. Assert.Equal(10, sum);
  530. }
  531. [Fact]
  532. public void ForEachAsync2()
  533. {
  534. var sum = 0;
  535. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  536. xs.ForEach((x, i) => sum += x * i);
  537. Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
  538. }
  539. [Fact]
  540. public void ForEach2()
  541. {
  542. var sum = 0;
  543. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  544. xs.ForEachAsync((x, i) => sum += x * i).Wait(WaitTimeoutMs);
  545. Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
  546. }
  547. [Fact]
  548. public void ForEachAsync3()
  549. {
  550. var ex = new Exception("Bang");
  551. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  552. AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  553. }
  554. [Fact]
  555. public void ForEach3()
  556. {
  557. var ex = new Exception("Bang");
  558. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  559. AssertThrows<Exception>(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  560. }
  561. [Fact]
  562. public void ForEachAsync4()
  563. {
  564. var ex = new Exception("Bang");
  565. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  566. AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  567. }
  568. [Fact]
  569. public void ForEach4()
  570. {
  571. var ex = new Exception("Bang");
  572. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  573. AssertThrows<Exception>(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  574. }
  575. [Fact]
  576. public void ForEachAsync5()
  577. {
  578. var ex = new Exception("Bang");
  579. var xs = AsyncEnumerable.Throw<int>(ex);
  580. AssertThrows<Exception>(() => xs.ForEachAsync(x => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  581. }
  582. [Fact]
  583. public void ForEach5()
  584. {
  585. var ex = new Exception("Bang");
  586. var xs = AsyncEnumerable.Throw<int>(ex);
  587. AssertThrows<Exception>(() => xs.ForEach(x => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  588. }
  589. [Fact]
  590. public void ForEachAsync6()
  591. {
  592. var ex = new Exception("Bang");
  593. var xs = AsyncEnumerable.Throw<int>(ex);
  594. AssertThrows<Exception>(() => xs.ForEachAsync((x, i) => { throw ex; }).Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  595. }
  596. [Fact]
  597. public void ForEach6()
  598. {
  599. var ex = new Exception("Bang");
  600. var xs = AsyncEnumerable.Throw<int>(ex);
  601. AssertThrows<Exception>(() => xs.ForEach((x, i) => { throw ex; }), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  602. }
  603. [Fact]
  604. public void Take_Null()
  605. {
  606. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Take<int>(null, 5));
  607. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Take<int>(AsyncEnumerable.Return(42), -1));
  608. }
  609. [Fact]
  610. public void Take1()
  611. {
  612. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  613. var ys = xs.Take(2);
  614. var e = ys.GetEnumerator();
  615. HasNext(e, 1);
  616. HasNext(e, 2);
  617. NoNext(e);
  618. }
  619. [Fact]
  620. public void Take2()
  621. {
  622. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  623. var ys = xs.Take(10);
  624. var e = ys.GetEnumerator();
  625. HasNext(e, 1);
  626. HasNext(e, 2);
  627. HasNext(e, 3);
  628. HasNext(e, 4);
  629. NoNext(e);
  630. }
  631. [Fact]
  632. public void Take3()
  633. {
  634. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  635. var ys = xs.Take(0);
  636. var e = ys.GetEnumerator();
  637. NoNext(e);
  638. }
  639. [Fact]
  640. public void Take4()
  641. {
  642. var ex = new Exception("Bang");
  643. var xs = AsyncEnumerable.Throw<int>(ex);
  644. var ys = xs.Take(2);
  645. var e = ys.GetEnumerator();
  646. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  647. }
  648. [Fact]
  649. public void TakeWhile_Null()
  650. {
  651. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, x => true));
  652. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(null, (x, i) => true));
  653. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
  654. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
  655. }
  656. [Fact]
  657. public void TakeWhile1()
  658. {
  659. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  660. var ys = xs.TakeWhile(x => x < 3);
  661. var e = ys.GetEnumerator();
  662. HasNext(e, 1);
  663. HasNext(e, 2);
  664. NoNext(e);
  665. }
  666. [Fact]
  667. public void TakeWhile2()
  668. {
  669. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  670. var ys = xs.TakeWhile(x => false);
  671. var e = ys.GetEnumerator();
  672. NoNext(e);
  673. }
  674. [Fact]
  675. public void TakeWhile3()
  676. {
  677. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  678. var ys = xs.TakeWhile(x => true);
  679. var e = ys.GetEnumerator();
  680. HasNext(e, 1);
  681. HasNext(e, 2);
  682. HasNext(e, 3);
  683. HasNext(e, 4);
  684. NoNext(e);
  685. }
  686. [Fact]
  687. public void TakeWhile4()
  688. {
  689. var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
  690. var ys = xs.TakeWhile(x => x < 3);
  691. var e = ys.GetEnumerator();
  692. HasNext(e, 1);
  693. HasNext(e, 2);
  694. NoNext(e);
  695. }
  696. [Fact]
  697. public void TakeWhile5()
  698. {
  699. var ex = new Exception("Bang");
  700. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  701. var ys = xs.TakeWhile(x => { throw ex; });
  702. var e = ys.GetEnumerator();
  703. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  704. }
  705. [Fact]
  706. public void TakeWhile6()
  707. {
  708. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  709. var ys = xs.TakeWhile((x, i) => i < 2);
  710. var e = ys.GetEnumerator();
  711. HasNext(e, 1);
  712. HasNext(e, 2);
  713. NoNext(e);
  714. }
  715. [Fact]
  716. public void TakeWhile7()
  717. {
  718. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  719. var ys = xs.TakeWhile((x, i) => false);
  720. var e = ys.GetEnumerator();
  721. NoNext(e);
  722. }
  723. [Fact]
  724. public void TakeWhile8()
  725. {
  726. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  727. var ys = xs.TakeWhile((x, i) => true);
  728. var e = ys.GetEnumerator();
  729. HasNext(e, 1);
  730. HasNext(e, 2);
  731. HasNext(e, 3);
  732. HasNext(e, 4);
  733. NoNext(e);
  734. }
  735. [Fact]
  736. public void TakeWhile9()
  737. {
  738. var ex = new Exception("Bang");
  739. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  740. var ys = xs.TakeWhile((x, i) => { throw ex; });
  741. var e = ys.GetEnumerator();
  742. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  743. }
  744. [Fact]
  745. public void Skip_Null()
  746. {
  747. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Skip<int>(null, 5));
  748. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Skip<int>(AsyncEnumerable.Return(42), -1));
  749. }
  750. [Fact]
  751. public void Skip1()
  752. {
  753. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  754. var ys = xs.Skip(2);
  755. var e = ys.GetEnumerator();
  756. HasNext(e, 3);
  757. HasNext(e, 4);
  758. NoNext(e);
  759. }
  760. [Fact]
  761. public void Skip2()
  762. {
  763. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  764. var ys = xs.Skip(10);
  765. var e = ys.GetEnumerator();
  766. NoNext(e);
  767. }
  768. [Fact]
  769. public void Skip3()
  770. {
  771. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  772. var ys = xs.Skip(0);
  773. var e = ys.GetEnumerator();
  774. HasNext(e, 1);
  775. HasNext(e, 2);
  776. HasNext(e, 3);
  777. HasNext(e, 4);
  778. NoNext(e);
  779. }
  780. [Fact]
  781. public void Skip4()
  782. {
  783. var ex = new Exception("Bang");
  784. var xs = AsyncEnumerable.Throw<int>(ex);
  785. var ys = xs.Skip(2);
  786. var e = ys.GetEnumerator();
  787. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  788. }
  789. [Fact]
  790. public void SkipWhile_Null()
  791. {
  792. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, x => true));
  793. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(null, (x, i) => true));
  794. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, bool>)));
  795. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(AsyncEnumerable.Return(42), default(Func<int, int, bool>)));
  796. }
  797. [Fact]
  798. public void SkipWhile1()
  799. {
  800. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  801. var ys = xs.SkipWhile(x => x < 3);
  802. var e = ys.GetEnumerator();
  803. HasNext(e, 3);
  804. HasNext(e, 4);
  805. NoNext(e);
  806. }
  807. [Fact]
  808. public void SkipWhile2()
  809. {
  810. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  811. var ys = xs.SkipWhile(x => false);
  812. var e = ys.GetEnumerator();
  813. HasNext(e, 1);
  814. HasNext(e, 2);
  815. HasNext(e, 3);
  816. HasNext(e, 4);
  817. NoNext(e);
  818. }
  819. [Fact]
  820. public void SkipWhile3()
  821. {
  822. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  823. var ys = xs.SkipWhile(x => true);
  824. var e = ys.GetEnumerator();
  825. NoNext(e);
  826. }
  827. [Fact]
  828. public void SkipWhile4()
  829. {
  830. var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
  831. var ys = xs.SkipWhile(x => x < 3);
  832. var e = ys.GetEnumerator();
  833. HasNext(e, 3);
  834. HasNext(e, 4);
  835. HasNext(e, 3);
  836. HasNext(e, 2);
  837. HasNext(e, 1);
  838. NoNext(e);
  839. }
  840. [Fact]
  841. public void SkipWhile5()
  842. {
  843. var ex = new Exception("Bang");
  844. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  845. var ys = xs.SkipWhile(x => { throw ex; });
  846. var e = ys.GetEnumerator();
  847. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  848. }
  849. [Fact]
  850. public void SkipWhile6()
  851. {
  852. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  853. var ys = xs.SkipWhile((x, i) => i < 2);
  854. var e = ys.GetEnumerator();
  855. HasNext(e, 3);
  856. HasNext(e, 4);
  857. NoNext(e);
  858. }
  859. [Fact]
  860. public void SkipWhile7()
  861. {
  862. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  863. var ys = xs.SkipWhile((x, i) => false);
  864. var e = ys.GetEnumerator();
  865. HasNext(e, 1);
  866. HasNext(e, 2);
  867. HasNext(e, 3);
  868. HasNext(e, 4);
  869. NoNext(e);
  870. }
  871. [Fact]
  872. public void SkipWhile8()
  873. {
  874. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  875. var ys = xs.SkipWhile((x, i) => true);
  876. var e = ys.GetEnumerator();
  877. NoNext(e);
  878. }
  879. [Fact]
  880. public void SkipWhile9()
  881. {
  882. var ex = new Exception("Bang");
  883. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
  884. var ys = xs.SkipWhile((x, i) => { throw ex; });
  885. var e = ys.GetEnumerator();
  886. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  887. }
  888. [Fact]
  889. public void DefaultIfEmpty_Null()
  890. {
  891. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty<int>(null));
  892. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DefaultIfEmpty<int>(null, 42));
  893. }
  894. [Fact]
  895. public void DefaultIfEmpty1()
  896. {
  897. var xs = AsyncEnumerable.Empty<int>().DefaultIfEmpty();
  898. var e = xs.GetEnumerator();
  899. HasNext(e, 0);
  900. NoNext(e);
  901. }
  902. [Fact]
  903. public void DefaultIfEmpty2()
  904. {
  905. var xs = AsyncEnumerable.Empty<int>().DefaultIfEmpty(42);
  906. var e = xs.GetEnumerator();
  907. HasNext(e, 42);
  908. NoNext(e);
  909. }
  910. [Fact]
  911. public void DefaultIfEmpty3()
  912. {
  913. var xs = AsyncEnumerable.Return<int>(42).DefaultIfEmpty();
  914. var e = xs.GetEnumerator();
  915. HasNext(e, 42);
  916. NoNext(e);
  917. }
  918. [Fact]
  919. public void DefaultIfEmpty4()
  920. {
  921. var xs = AsyncEnumerable.Return<int>(42).DefaultIfEmpty(24);
  922. var e = xs.GetEnumerator();
  923. HasNext(e, 42);
  924. NoNext(e);
  925. }
  926. [Fact]
  927. public void DefaultIfEmpty5()
  928. {
  929. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty();
  930. var e = xs.GetEnumerator();
  931. HasNext(e, 1);
  932. HasNext(e, 2);
  933. HasNext(e, 3);
  934. HasNext(e, 4);
  935. NoNext(e);
  936. }
  937. [Fact]
  938. public void DefaultIfEmpty6()
  939. {
  940. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().DefaultIfEmpty(24);
  941. var e = xs.GetEnumerator();
  942. HasNext(e, 1);
  943. HasNext(e, 2);
  944. HasNext(e, 3);
  945. HasNext(e, 4);
  946. NoNext(e);
  947. }
  948. [Fact]
  949. public void DefaultIfEmpty7()
  950. {
  951. var ex = new Exception("Bang!");
  952. var xs = AsyncEnumerable.Throw<int>(ex).DefaultIfEmpty();
  953. var e = xs.GetEnumerator();
  954. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  955. }
  956. [Fact]
  957. public void DefaultIfEmpty8()
  958. {
  959. var ex = new Exception("Bang!");
  960. var xs = AsyncEnumerable.Throw<int>(ex).DefaultIfEmpty(24);
  961. var e = xs.GetEnumerator();
  962. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  963. }
  964. [Fact]
  965. public void Distinct_Null()
  966. {
  967. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct<int>(null));
  968. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct<int>(null, new Eq()));
  969. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct<int>(AsyncEnumerable.Return(42), null));
  970. }
  971. [Fact]
  972. public void Distinct1()
  973. {
  974. var xs = new[] { 1, 2, 1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct();
  975. var e = xs.GetEnumerator();
  976. HasNext(e, 1);
  977. HasNext(e, 2);
  978. HasNext(e, 3);
  979. HasNext(e, 5);
  980. HasNext(e, 4);
  981. NoNext(e);
  982. }
  983. [Fact]
  984. public void Distinct2()
  985. {
  986. var xs = new[] { 1, -2, -1, 3, 5, 2, 1, 4 }.ToAsyncEnumerable().Distinct(new Eq());
  987. var e = xs.GetEnumerator();
  988. HasNext(e, 1);
  989. HasNext(e, -2);
  990. HasNext(e, 3);
  991. HasNext(e, 5);
  992. HasNext(e, 4);
  993. NoNext(e);
  994. }
  995. [Fact]
  996. public void Reverse_Null()
  997. {
  998. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Reverse<int>(null));
  999. }
  1000. [Fact]
  1001. public void Reverse1()
  1002. {
  1003. var xs = AsyncEnumerable.Empty<int>();
  1004. var ys = xs.Reverse();
  1005. var e = ys.GetEnumerator();
  1006. NoNext(e);
  1007. }
  1008. [Fact]
  1009. public void Reverse2()
  1010. {
  1011. var xs = AsyncEnumerable.Return(42);
  1012. var ys = xs.Reverse();
  1013. var e = ys.GetEnumerator();
  1014. HasNext(e, 42);
  1015. NoNext(e);
  1016. }
  1017. [Fact]
  1018. public void Reverse3()
  1019. {
  1020. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  1021. var ys = xs.Reverse();
  1022. var e = ys.GetEnumerator();
  1023. HasNext(e, 3);
  1024. HasNext(e, 2);
  1025. HasNext(e, 1);
  1026. NoNext(e);
  1027. }
  1028. [Fact]
  1029. public void Reverse4()
  1030. {
  1031. var ex = new Exception("Bang!");
  1032. var xs = AsyncEnumerable.Throw<int>(ex);
  1033. var ys = xs.Reverse();
  1034. var e = ys.GetEnumerator();
  1035. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1036. }
  1037. [Fact]
  1038. public void OrderBy_Null()
  1039. {
  1040. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(null, x => x));
  1041. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(AsyncEnumerable.Return(42), null));
  1042. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(null, x => x, Comparer<int>.Default));
  1043. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(AsyncEnumerable.Return(42), null, Comparer<int>.Default));
  1044. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(AsyncEnumerable.Return(42), x => x, null));
  1045. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(null, x => x));
  1046. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(AsyncEnumerable.Return(42), null));
  1047. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(null, x => x, Comparer<int>.Default));
  1048. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(AsyncEnumerable.Return(42), null, Comparer<int>.Default));
  1049. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(AsyncEnumerable.Return(42), x => x, null));
  1050. var xs = AsyncEnumerable.Return(42).OrderBy(x => x);
  1051. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(null, x => x));
  1052. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(xs, null));
  1053. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(null, x => x, Comparer<int>.Default));
  1054. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(xs, null, Comparer<int>.Default));
  1055. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(xs, x => x, null));
  1056. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(null, x => x));
  1057. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(xs, null));
  1058. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(null, x => x, Comparer<int>.Default));
  1059. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(xs, null, Comparer<int>.Default));
  1060. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(xs, x => x, null));
  1061. }
  1062. [Fact]
  1063. public void OrderBy1()
  1064. {
  1065. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1066. var ys = xs.OrderBy(x => x);
  1067. var e = ys.GetEnumerator();
  1068. for (int i = 0; i < 10; i++)
  1069. HasNext(e, i);
  1070. NoNext(e);
  1071. }
  1072. [Fact]
  1073. public void OrderBy2()
  1074. {
  1075. var ex = new Exception("Bang!");
  1076. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1077. var ys = xs.OrderBy<int, int>(x => { throw ex; });
  1078. var e = ys.GetEnumerator();
  1079. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1080. }
  1081. [Fact]
  1082. public void ThenBy2()
  1083. {
  1084. var ex = new Exception("Bang!");
  1085. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1086. var ys = xs.OrderBy<int, int>(x => x).ThenBy<int, int>(x => { throw ex; });
  1087. var e = ys.GetEnumerator();
  1088. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1089. }
  1090. [Fact]
  1091. public void OrderByDescending1()
  1092. {
  1093. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1094. var ys = xs.OrderByDescending(x => x);
  1095. var e = ys.GetEnumerator();
  1096. for (int i = 9; i >= 0; i--)
  1097. HasNext(e, i);
  1098. NoNext(e);
  1099. }
  1100. [Fact]
  1101. public void OrderByDescending2()
  1102. {
  1103. var ex = new Exception("Bang!");
  1104. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1105. var ys = xs.OrderByDescending<int, int>(x => { throw ex; });
  1106. var e = ys.GetEnumerator();
  1107. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1108. }
  1109. [Fact]
  1110. public void ThenByDescending2()
  1111. {
  1112. var ex = new Exception("Bang!");
  1113. var xs = new[] { 2, 6, 1, 5, 7, 8, 9, 3, 4, 0 }.ToAsyncEnumerable();
  1114. var ys = xs.OrderBy<int, int>(x => x).ThenByDescending<int, int>(x => { throw ex; });
  1115. var e = ys.GetEnumerator();
  1116. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1117. }
  1118. [Fact]
  1119. public void OrderByThenBy1()
  1120. {
  1121. var xs = new[] {
  1122. new { Name = "Bart", Age = 27 },
  1123. new { Name = "John", Age = 62 },
  1124. new { Name = "Eric", Age = 27 },
  1125. new { Name = "Lisa", Age = 14 },
  1126. new { Name = "Brad", Age = 27 },
  1127. new { Name = "Lisa", Age = 23 },
  1128. new { Name = "Eric", Age = 42 },
  1129. };
  1130. var ys = xs.ToAsyncEnumerable();
  1131. var ress = xs.OrderBy(x => x.Name).ThenBy(x => x.Age);
  1132. var resa = ys.OrderBy(x => x.Name).ThenBy(x => x.Age);
  1133. Assert.True(ress.SequenceEqual(resa.ToEnumerable()));
  1134. }
  1135. [Fact]
  1136. public void OrderByThenBy2()
  1137. {
  1138. var xs = new[] {
  1139. new { Name = "Bart", Age = 27 },
  1140. new { Name = "John", Age = 62 },
  1141. new { Name = "Eric", Age = 27 },
  1142. new { Name = "Lisa", Age = 14 },
  1143. new { Name = "Brad", Age = 27 },
  1144. new { Name = "Lisa", Age = 23 },
  1145. new { Name = "Eric", Age = 42 },
  1146. };
  1147. var ys = xs.ToAsyncEnumerable();
  1148. var ress = xs.OrderBy(x => x.Name).ThenByDescending(x => x.Age);
  1149. var resa = ys.OrderBy(x => x.Name).ThenByDescending(x => x.Age);
  1150. Assert.True(ress.SequenceEqual(resa.ToEnumerable()));
  1151. }
  1152. [Fact]
  1153. public void OrderByThenBy3()
  1154. {
  1155. var xs = new[] {
  1156. new { Name = "Bart", Age = 27 },
  1157. new { Name = "John", Age = 62 },
  1158. new { Name = "Eric", Age = 27 },
  1159. new { Name = "Lisa", Age = 14 },
  1160. new { Name = "Brad", Age = 27 },
  1161. new { Name = "Lisa", Age = 23 },
  1162. new { Name = "Eric", Age = 42 },
  1163. };
  1164. var ys = xs.ToAsyncEnumerable();
  1165. var ress = xs.OrderByDescending(x => x.Name).ThenBy(x => x.Age);
  1166. var resa = ys.OrderByDescending(x => x.Name).ThenBy(x => x.Age);
  1167. Assert.True(ress.SequenceEqual(resa.ToEnumerable()));
  1168. }
  1169. [Fact]
  1170. public void OrderByThenBy4()
  1171. {
  1172. var xs = new[] {
  1173. new { Name = "Bart", Age = 27 },
  1174. new { Name = "John", Age = 62 },
  1175. new { Name = "Eric", Age = 27 },
  1176. new { Name = "Lisa", Age = 14 },
  1177. new { Name = "Brad", Age = 27 },
  1178. new { Name = "Lisa", Age = 23 },
  1179. new { Name = "Eric", Age = 42 },
  1180. };
  1181. var ys = xs.ToAsyncEnumerable();
  1182. var ress = xs.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age);
  1183. var resa = ys.OrderByDescending(x => x.Name).ThenByDescending(x => x.Age);
  1184. Assert.True(ress.SequenceEqual(resa.ToEnumerable()));
  1185. }
  1186. [Fact]
  1187. public void GroupBy_Null()
  1188. {
  1189. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(null, x => x));
  1190. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(AsyncEnumerable.Return(42), default(Func<int, int>)));
  1191. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(null, x => x, EqualityComparer<int>.Default));
  1192. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), EqualityComparer<int>.Default));
  1193. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer<int>)));
  1194. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(null, x => x, x => x));
  1195. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), x => x));
  1196. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, int>)));
  1197. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(null, x => x, x => x, EqualityComparer<int>.Default));
  1198. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), x => x, EqualityComparer<int>.Default));
  1199. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, int>), EqualityComparer<int>.Default));
  1200. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, x => x, default(IEqualityComparer<int>)));
  1201. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(null, x => x, (x, ys) => x));
  1202. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), (x, ys) => x));
  1203. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, IAsyncEnumerable<int>, int>)));
  1204. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(null, x => x, (x, ys) => x, EqualityComparer<int>.Default));
  1205. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), (x, ys) => x, EqualityComparer<int>.Default));
  1206. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, IAsyncEnumerable<int>, int>), EqualityComparer<int>.Default));
  1207. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(AsyncEnumerable.Return(42), x => x, (x, ys) => x, default(IEqualityComparer<int>)));
  1208. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(null, x => x, x => x, (x, ys) => x));
  1209. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), x => x, (x, ys) => x));
  1210. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, int>), (x, ys) => x));
  1211. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), x => x, x => x, default(Func<int, IAsyncEnumerable<int>, int>)));
  1212. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(null, x => x, x => x, (x, ys) => x, EqualityComparer<int>.Default));
  1213. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), default(Func<int, int>), x => x, (x, ys) => x, EqualityComparer<int>.Default));
  1214. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), x => x, default(Func<int, int>), (x, ys) => x, EqualityComparer<int>.Default));
  1215. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), x => x, x => x, default(Func<int, IAsyncEnumerable<int>, int>), EqualityComparer<int>.Default));
  1216. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(AsyncEnumerable.Return(42), x => x, x => x, (x, ys) => x, default(IEqualityComparer<int>)));
  1217. }
  1218. [Fact]
  1219. public void GroupBy1()
  1220. {
  1221. var xs = new[] {
  1222. new { Name = "Bart", Age = 27 },
  1223. new { Name = "John", Age = 62 },
  1224. new { Name = "Eric", Age = 27 },
  1225. new { Name = "Lisa", Age = 14 },
  1226. new { Name = "Brad", Age = 27 },
  1227. new { Name = "Lisa", Age = 23 },
  1228. new { Name = "Eric", Age = 42 },
  1229. };
  1230. var ys = xs.ToAsyncEnumerable();
  1231. var res = ys.GroupBy(x => x.Age / 10);
  1232. var e = res.GetEnumerator();
  1233. Assert.True(e.MoveNext().Result);
  1234. Assert.Equal(e.Current.Key, 2);
  1235. var g1 = e.Current.GetEnumerator();
  1236. HasNext(g1, xs[0]);
  1237. HasNext(g1, xs[2]);
  1238. HasNext(g1, xs[4]);
  1239. HasNext(g1, xs[5]);
  1240. NoNext(g1);
  1241. Assert.True(e.MoveNext().Result);
  1242. Assert.Equal(e.Current.Key, 6);
  1243. var g2 = e.Current.GetEnumerator();
  1244. HasNext(g2, xs[1]);
  1245. NoNext(g2);
  1246. Assert.True(e.MoveNext().Result);
  1247. Assert.Equal(e.Current.Key, 1);
  1248. var g3 = e.Current.GetEnumerator();
  1249. HasNext(g3, xs[3]);
  1250. NoNext(g3);
  1251. Assert.True(e.MoveNext().Result);
  1252. Assert.Equal(e.Current.Key, 4);
  1253. var g4 = e.Current.GetEnumerator();
  1254. HasNext(g4, xs[6]);
  1255. NoNext(g4);
  1256. NoNext(e);
  1257. }
  1258. [Fact]
  1259. public void GroupBy2()
  1260. {
  1261. var xs = new[] {
  1262. new { Name = "Bart", Age = 27 },
  1263. new { Name = "John", Age = 62 },
  1264. new { Name = "Eric", Age = 27 },
  1265. new { Name = "Lisa", Age = 14 },
  1266. new { Name = "Brad", Age = 27 },
  1267. new { Name = "Lisa", Age = 23 },
  1268. new { Name = "Eric", Age = 42 },
  1269. };
  1270. var ys = xs.ToAsyncEnumerable();
  1271. var res = ys.GroupBy(x => x.Age / 10);
  1272. var e = res.GetEnumerator();
  1273. Assert.True(e.MoveNext().Result);
  1274. var g1 = e.Current;
  1275. Assert.Equal(g1.Key, 2);
  1276. Assert.True(e.MoveNext().Result);
  1277. var g2 = e.Current;
  1278. Assert.Equal(g2.Key, 6);
  1279. Assert.True(e.MoveNext().Result);
  1280. var g3 = e.Current;
  1281. Assert.Equal(g3.Key, 1);
  1282. Assert.True(e.MoveNext().Result);
  1283. var g4 = e.Current;
  1284. Assert.Equal(g4.Key, 4);
  1285. NoNext(e);
  1286. var g1e = g1.GetEnumerator();
  1287. HasNext(g1e, xs[0]);
  1288. HasNext(g1e, xs[2]);
  1289. HasNext(g1e, xs[4]);
  1290. HasNext(g1e, xs[5]);
  1291. NoNext(g1e);
  1292. var g2e = g2.GetEnumerator();
  1293. HasNext(g2e, xs[1]);
  1294. NoNext(g2e);
  1295. var g3e = g3.GetEnumerator();
  1296. HasNext(g3e, xs[3]);
  1297. NoNext(g3e);
  1298. var g4e = g4.GetEnumerator();
  1299. HasNext(g4e, xs[6]);
  1300. NoNext(g4e);
  1301. }
  1302. [Fact]
  1303. public void GroupBy3()
  1304. {
  1305. var xs = AsyncEnumerable.Empty<int>();
  1306. var ys = xs.GroupBy(x => x);
  1307. var e = ys.GetEnumerator();
  1308. NoNext(e);
  1309. }
  1310. [Fact]
  1311. public void GroupBy4()
  1312. {
  1313. var ex = new Exception("Bang!");
  1314. var xs = AsyncEnumerable.Throw<int>(ex);
  1315. var ys = xs.GroupBy(x => x);
  1316. var e = ys.GetEnumerator();
  1317. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1318. }
  1319. [Fact]
  1320. public void GroupBy5()
  1321. {
  1322. var xs = GetXs().ToAsyncEnumerable();
  1323. var ys = xs.GroupBy(x => x);
  1324. var e = ys.GetEnumerator();
  1325. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
  1326. //Assert.True(e.MoveNext().Result);
  1327. //var g1 = e.Current;
  1328. //Assert.Equal(g1.Key, 42);
  1329. //var g1e = g1.GetEnumerator();
  1330. //HasNext(g1e, 42);
  1331. //Assert.True(e.MoveNext().Result);
  1332. //var g2 = e.Current;
  1333. //Assert.Equal(g2.Key, 43);
  1334. //var g2e = g2.GetEnumerator();
  1335. //HasNext(g2e, 43);
  1336. //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
  1337. //AssertThrows<Exception>(() => g2e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
  1338. }
  1339. [Fact]
  1340. public void GroupBy6()
  1341. {
  1342. var xs = GetXs().ToAsyncEnumerable();
  1343. var ys = xs.GroupBy(x => x);
  1344. var e = ys.GetEnumerator();
  1345. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
  1346. //Assert.True(e.MoveNext().Result);
  1347. //var g1 = e.Current;
  1348. //Assert.Equal(g1.Key, 42);
  1349. //var g1e = g1.GetEnumerator();
  1350. //HasNext(g1e, 42);
  1351. //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
  1352. }
  1353. static IEnumerable<int> GetXs()
  1354. {
  1355. yield return 42;
  1356. yield return 43;
  1357. throw new Exception("Bang!");
  1358. }
  1359. [Fact]
  1360. public void GroupBy7()
  1361. {
  1362. var ex = new Exception("Bang!");
  1363. var xs = AsyncEnumerable.Return(42);
  1364. var ys = xs.GroupBy<int, int>(x => { throw ex; });
  1365. var e = ys.GetEnumerator();
  1366. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1367. }
  1368. [Fact]
  1369. public void GroupBy8()
  1370. {
  1371. var ex = new Exception("Bang!");
  1372. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
  1373. var ys = xs.GroupBy<int, int>(x => { if (x == 3) throw ex; return x; });
  1374. var e = ys.GetEnumerator();
  1375. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1376. //Assert.True(e.MoveNext().Result);
  1377. //var g1 = e.Current;
  1378. //Assert.Equal(g1.Key, 1);
  1379. //var g1e = g1.GetEnumerator();
  1380. //HasNext(g1e, 1);
  1381. //Assert.True(e.MoveNext().Result);
  1382. //var g2 = e.Current;
  1383. //Assert.Equal(g2.Key, 2);
  1384. //var g2e = g2.GetEnumerator();
  1385. //HasNext(g2e, 2);
  1386. //AssertThrows<Exception>(() => g1e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1387. //AssertThrows<Exception>(() => g2e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1388. }
  1389. [Fact]
  1390. public void GroupBy9()
  1391. {
  1392. var xs = AsyncEnumerable.Range(0, 10);
  1393. var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x));
  1394. var e = ys.GetEnumerator();
  1395. Assert.True(e.MoveNext().Result);
  1396. var g1 = e.Current;
  1397. Assert.Equal(g1.Key, 0);
  1398. var g1e = g1.GetEnumerator();
  1399. HasNext(g1e, 'a');
  1400. HasNext(g1e, 'd');
  1401. HasNext(g1e, 'g');
  1402. HasNext(g1e, 'j');
  1403. NoNext(g1e);
  1404. Assert.True(e.MoveNext().Result);
  1405. var g2 = e.Current;
  1406. Assert.Equal(g2.Key, 1);
  1407. var g2e = g2.GetEnumerator();
  1408. HasNext(g2e, 'b');
  1409. HasNext(g2e, 'e');
  1410. HasNext(g2e, 'h');
  1411. NoNext(g2e);
  1412. Assert.True(e.MoveNext().Result);
  1413. var g3 = e.Current;
  1414. Assert.Equal(g3.Key, 2);
  1415. var g3e = g3.GetEnumerator();
  1416. HasNext(g3e, 'c');
  1417. HasNext(g3e, 'f');
  1418. HasNext(g3e, 'i');
  1419. NoNext(g3e);
  1420. NoNext(e);
  1421. }
  1422. [Fact]
  1423. public void GroupBy10()
  1424. {
  1425. var xs = AsyncEnumerable.Range(0, 10);
  1426. var ys = xs.GroupBy(x => x % 3, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result);
  1427. var e = ys.GetEnumerator();
  1428. HasNext(e, "0 - adgj");
  1429. HasNext(e, "1 - beh");
  1430. HasNext(e, "2 - cfi");
  1431. NoNext(e);
  1432. }
  1433. [Fact]
  1434. public void GroupBy11()
  1435. {
  1436. var xs = AsyncEnumerable.Range(0, 10);
  1437. var ys = xs.GroupBy(x => x % 3, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result);
  1438. var e = ys.GetEnumerator();
  1439. HasNext(e, "0 - 0369");
  1440. HasNext(e, "1 - 147");
  1441. HasNext(e, "2 - 258");
  1442. NoNext(e);
  1443. }
  1444. [Fact]
  1445. public void GroupBy12()
  1446. {
  1447. var xs = AsyncEnumerable.Range(0, 10);
  1448. var ys = xs.GroupBy(x => x, new EqMod(3));
  1449. var e = ys.GetEnumerator();
  1450. Assert.True(e.MoveNext().Result);
  1451. var g1 = e.Current;
  1452. Assert.Equal(g1.Key, 0);
  1453. var g1e = g1.GetEnumerator();
  1454. HasNext(g1e, 0);
  1455. HasNext(g1e, 3);
  1456. HasNext(g1e, 6);
  1457. HasNext(g1e, 9);
  1458. NoNext(g1e);
  1459. Assert.True(e.MoveNext().Result);
  1460. var g2 = e.Current;
  1461. Assert.Equal(g2.Key, 1);
  1462. var g2e = g2.GetEnumerator();
  1463. HasNext(g2e, 1);
  1464. HasNext(g2e, 4);
  1465. HasNext(g2e, 7);
  1466. NoNext(g2e);
  1467. Assert.True(e.MoveNext().Result);
  1468. var g3 = e.Current;
  1469. Assert.Equal(g3.Key, 2);
  1470. var g3e = g3.GetEnumerator();
  1471. HasNext(g3e, 2);
  1472. HasNext(g3e, 5);
  1473. HasNext(g3e, 8);
  1474. NoNext(g3e);
  1475. NoNext(e);
  1476. }
  1477. [Fact]
  1478. public void GroupBy13()
  1479. {
  1480. var xs = AsyncEnumerable.Range(0, 10);
  1481. var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3));
  1482. var e = ys.GetEnumerator();
  1483. Assert.True(e.MoveNext().Result);
  1484. var g1 = e.Current;
  1485. Assert.Equal(g1.Key, 0);
  1486. var g1e = g1.GetEnumerator();
  1487. HasNext(g1e, 'a');
  1488. HasNext(g1e, 'd');
  1489. HasNext(g1e, 'g');
  1490. HasNext(g1e, 'j');
  1491. NoNext(g1e);
  1492. Assert.True(e.MoveNext().Result);
  1493. var g2 = e.Current;
  1494. Assert.Equal(g2.Key, 1);
  1495. var g2e = g2.GetEnumerator();
  1496. HasNext(g2e, 'b');
  1497. HasNext(g2e, 'e');
  1498. HasNext(g2e, 'h');
  1499. NoNext(g2e);
  1500. Assert.True(e.MoveNext().Result);
  1501. var g3 = e.Current;
  1502. Assert.Equal(g3.Key, 2);
  1503. var g3e = g3.GetEnumerator();
  1504. HasNext(g3e, 'c');
  1505. HasNext(g3e, 'f');
  1506. HasNext(g3e, 'i');
  1507. NoNext(g3e);
  1508. NoNext(e);
  1509. }
  1510. [Fact]
  1511. public void GroupBy14()
  1512. {
  1513. var xs = AsyncEnumerable.Range(0, 10);
  1514. var ys = xs.GroupBy(x => x, x => (char)('a' + x), (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3));
  1515. var e = ys.GetEnumerator();
  1516. HasNext(e, "0 - adgj");
  1517. HasNext(e, "1 - beh");
  1518. HasNext(e, "2 - cfi");
  1519. NoNext(e);
  1520. }
  1521. [Fact]
  1522. public void GroupBy15()
  1523. {
  1524. var xs = AsyncEnumerable.Range(0, 10);
  1525. var ys = xs.GroupBy(x => x, (k, cs) => k + " - " + cs.Aggregate("", (a, c) => a + c).Result, new EqMod(3));
  1526. var e = ys.GetEnumerator();
  1527. HasNext(e, "0 - 0369");
  1528. HasNext(e, "1 - 147");
  1529. HasNext(e, "2 - 258");
  1530. NoNext(e);
  1531. }
  1532. [Fact]
  1533. public void GroupBy16()
  1534. {
  1535. var xs = AsyncEnumerable.Range(0, 10);
  1536. var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3));
  1537. var e = ys.GetEnumerator();
  1538. Assert.True(e.MoveNext().Result);
  1539. var g1 = e.Current;
  1540. Assert.Equal(g1.Key, 0);
  1541. var g1e = g1.GetEnumerator();
  1542. HasNext(g1e, 'a');
  1543. HasNext(g1e, 'd');
  1544. HasNext(g1e, 'g');
  1545. HasNext(g1e, 'j');
  1546. NoNext(g1e);
  1547. g1e.Dispose();
  1548. Assert.True(e.MoveNext().Result);
  1549. var g2 = e.Current;
  1550. Assert.Equal(g2.Key, 1);
  1551. var g2e = g2.GetEnumerator();
  1552. HasNext(g2e, 'b');
  1553. HasNext(g2e, 'e');
  1554. HasNext(g2e, 'h');
  1555. NoNext(g2e);
  1556. g2e.Dispose();
  1557. Assert.True(e.MoveNext().Result);
  1558. var g3 = e.Current;
  1559. Assert.Equal(g3.Key, 2);
  1560. var g3e = g3.GetEnumerator();
  1561. HasNext(g3e, 'c');
  1562. HasNext(g3e, 'f');
  1563. HasNext(g3e, 'i');
  1564. NoNext(g3e);
  1565. g3e.Dispose();
  1566. NoNext(e);
  1567. e.Dispose();
  1568. }
  1569. [Fact]
  1570. public void GroupBy17()
  1571. {
  1572. var xs = AsyncEnumerable.Range(0, 10);
  1573. var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3));
  1574. var e = ys.GetEnumerator();
  1575. e.Dispose();
  1576. Assert.False(e.MoveNext().Result);
  1577. }
  1578. [Fact]
  1579. public void GroupBy18()
  1580. {
  1581. var xs = AsyncEnumerable.Range(0, 10);
  1582. var ys = xs.GroupBy(x => x, x => (char)('a' + x), new EqMod(3));
  1583. var e = ys.GetEnumerator();
  1584. Assert.True(e.MoveNext().Result);
  1585. var g1 = e.Current;
  1586. Assert.Equal(g1.Key, 0);
  1587. var g1e = g1.GetEnumerator();
  1588. HasNext(g1e, 'a');
  1589. e.Dispose();
  1590. HasNext(g1e, 'd');
  1591. HasNext(g1e, 'g');
  1592. HasNext(g1e, 'j');
  1593. NoNext(g1e);
  1594. g1e.Dispose();
  1595. Assert.False(e.MoveNext().Result);
  1596. }
  1597. class EqMod : IEqualityComparer<int>
  1598. {
  1599. private readonly int _d;
  1600. public EqMod(int d)
  1601. {
  1602. _d = d;
  1603. }
  1604. public bool Equals(int x, int y)
  1605. {
  1606. return EqualityComparer<int>.Default.Equals(x % _d, y % _d);
  1607. }
  1608. public int GetHashCode(int obj)
  1609. {
  1610. return EqualityComparer<int>.Default.GetHashCode(obj % _d);
  1611. }
  1612. }
  1613. [Fact]
  1614. public void AsAsyncEnumerable_Null()
  1615. {
  1616. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.AsAsyncEnumerable<int>((IAsyncEnumerable<int>)null));
  1617. }
  1618. [Fact]
  1619. public void AsAsyncEnumerable1()
  1620. {
  1621. var xs = AsyncEnumerable.Return(42);
  1622. var ys = xs.AsAsyncEnumerable();
  1623. Assert.NotSame(xs, ys);
  1624. var e = xs.GetEnumerator();
  1625. HasNext(e, 42);
  1626. NoNext(e);
  1627. }
  1628. [Fact]
  1629. public void RepeatSeq_Null()
  1630. {
  1631. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable<int>)));
  1632. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Repeat(default(IAsyncEnumerable<int>), 3));
  1633. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Repeat(AsyncEnumerable.Return(42), -1));
  1634. }
  1635. [Fact]
  1636. public void RepeatSeq1()
  1637. {
  1638. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat();
  1639. var e = xs.GetEnumerator();
  1640. HasNext(e, 1);
  1641. HasNext(e, 2);
  1642. HasNext(e, 3);
  1643. HasNext(e, 1);
  1644. HasNext(e, 2);
  1645. HasNext(e, 3);
  1646. HasNext(e, 1);
  1647. HasNext(e, 2);
  1648. HasNext(e, 3);
  1649. }
  1650. [Fact]
  1651. public void RepeatSeq2()
  1652. {
  1653. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Repeat(3);
  1654. var e = xs.GetEnumerator();
  1655. HasNext(e, 1);
  1656. HasNext(e, 2);
  1657. HasNext(e, 3);
  1658. HasNext(e, 1);
  1659. HasNext(e, 2);
  1660. HasNext(e, 3);
  1661. HasNext(e, 1);
  1662. HasNext(e, 2);
  1663. HasNext(e, 3);
  1664. NoNext(e);
  1665. }
  1666. [Fact]
  1667. public void RepeatSeq3()
  1668. {
  1669. var i = 0;
  1670. var xs = RepeatXs(() => i++).ToAsyncEnumerable().Repeat(3);
  1671. var e = xs.GetEnumerator();
  1672. HasNext(e, 1);
  1673. HasNext(e, 2);
  1674. HasNext(e, 1);
  1675. HasNext(e, 2);
  1676. HasNext(e, 1);
  1677. HasNext(e, 2);
  1678. NoNext(e);
  1679. Assert.Equal(3, i);
  1680. }
  1681. static IEnumerable<int> RepeatXs(Action started)
  1682. {
  1683. started();
  1684. yield return 1;
  1685. yield return 2;
  1686. }
  1687. [Fact]
  1688. public void RepeatSeq4()
  1689. {
  1690. var xs = new FailRepeat().ToAsyncEnumerable().Repeat();
  1691. var e = xs.GetEnumerator();
  1692. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
  1693. }
  1694. [Fact]
  1695. public void RepeatSeq5()
  1696. {
  1697. var xs = new FailRepeat().ToAsyncEnumerable().Repeat(3);
  1698. var e = xs.GetEnumerator();
  1699. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
  1700. }
  1701. class FailRepeat : IEnumerable<int>
  1702. {
  1703. public IEnumerator<int> GetEnumerator()
  1704. {
  1705. throw new NotImplementedException();
  1706. }
  1707. System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  1708. {
  1709. throw new NotImplementedException();
  1710. }
  1711. }
  1712. [Fact]
  1713. public void IgnoreElements_Null()
  1714. {
  1715. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.IgnoreElements(default(IAsyncEnumerable<int>)));
  1716. }
  1717. [Fact]
  1718. public void IgnoreElements1()
  1719. {
  1720. var xs = AsyncEnumerable.Empty<int>().IgnoreElements();
  1721. var e = xs.GetEnumerator();
  1722. NoNext(e);
  1723. AssertThrows<InvalidOperationException>(() => { var ignored = e.Current; });
  1724. }
  1725. [Fact]
  1726. public void IgnoreElements2()
  1727. {
  1728. var xs = AsyncEnumerable.Return(42).IgnoreElements();
  1729. var e = xs.GetEnumerator();
  1730. NoNext(e);
  1731. AssertThrows<InvalidOperationException>(() => { var ignored = e.Current; });
  1732. }
  1733. [Fact]
  1734. public void IgnoreElements3()
  1735. {
  1736. var xs = AsyncEnumerable.Range(0, 10).IgnoreElements();
  1737. var e = xs.GetEnumerator();
  1738. NoNext(e);
  1739. AssertThrows<InvalidOperationException>(() => { var ignored = e.Current; });
  1740. }
  1741. [Fact]
  1742. public void IgnoreElements4()
  1743. {
  1744. var ex = new Exception("Bang!");
  1745. var xs = AsyncEnumerable.Throw<int>(ex).IgnoreElements();
  1746. var e = xs.GetEnumerator();
  1747. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1748. }
  1749. [Fact]
  1750. public void StartWith_Null()
  1751. {
  1752. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.StartWith(default(IAsyncEnumerable<int>), new[] { 1 }));
  1753. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.StartWith(AsyncEnumerable.Return(42), null));
  1754. }
  1755. [Fact]
  1756. public void StartWith1()
  1757. {
  1758. var xs = AsyncEnumerable.Empty<int>().StartWith(1, 2);
  1759. var e = xs.GetEnumerator();
  1760. HasNext(e, 1);
  1761. HasNext(e, 2);
  1762. NoNext(e);
  1763. }
  1764. [Fact]
  1765. public void StartWith2()
  1766. {
  1767. var xs = AsyncEnumerable.Return<int>(0).StartWith(1, 2);
  1768. var e = xs.GetEnumerator();
  1769. HasNext(e, 1);
  1770. HasNext(e, 2);
  1771. HasNext(e, 0);
  1772. NoNext(e);
  1773. }
  1774. [Fact]
  1775. public void StartWith3()
  1776. {
  1777. var ex = new Exception("Bang!");
  1778. var xs = AsyncEnumerable.Throw<int>(ex).StartWith(1, 2);
  1779. var e = xs.GetEnumerator();
  1780. HasNext(e, 1);
  1781. HasNext(e, 2);
  1782. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1783. }
  1784. [Fact]
  1785. public void Buffer_Null()
  1786. {
  1787. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable<int>), 1));
  1788. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Buffer(default(IAsyncEnumerable<int>), 1, 1));
  1789. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1));
  1790. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), -1, 1));
  1791. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Buffer(AsyncEnumerable.Return(42), 1, -1));
  1792. }
  1793. [Fact]
  1794. public void Buffer1()
  1795. {
  1796. var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2);
  1797. var e = xs.GetEnumerator();
  1798. Assert.True(e.MoveNext().Result);
  1799. Assert.True(e.Current.SequenceEqual(new[] { 1, 2 }));
  1800. Assert.True(e.MoveNext().Result);
  1801. Assert.True(e.Current.SequenceEqual(new[] { 3, 4 }));
  1802. Assert.True(e.MoveNext().Result);
  1803. Assert.True(e.Current.SequenceEqual(new[] { 5 }));
  1804. Assert.False(e.MoveNext().Result);
  1805. }
  1806. [Fact]
  1807. public void Buffer2()
  1808. {
  1809. var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(3, 2);
  1810. var e = xs.GetEnumerator();
  1811. Assert.True(e.MoveNext().Result);
  1812. Assert.True(e.Current.SequenceEqual(new[] { 1, 2, 3 }));
  1813. Assert.True(e.MoveNext().Result);
  1814. Assert.True(e.Current.SequenceEqual(new[] { 3, 4, 5 }));
  1815. Assert.True(e.MoveNext().Result);
  1816. Assert.True(e.Current.SequenceEqual(new[] { 5 }));
  1817. Assert.False(e.MoveNext().Result);
  1818. }
  1819. [Fact]
  1820. public void Buffer3()
  1821. {
  1822. var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Buffer(2, 3);
  1823. var e = xs.GetEnumerator();
  1824. Assert.True(e.MoveNext().Result);
  1825. Assert.True(e.Current.SequenceEqual(new[] { 1, 2 }));
  1826. Assert.True(e.MoveNext().Result);
  1827. Assert.True(e.Current.SequenceEqual(new[] { 4, 5 }));
  1828. Assert.False(e.MoveNext().Result);
  1829. }
  1830. [Fact]
  1831. public void DistinctUntilChanged_Null()
  1832. {
  1833. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable<int>)));
  1834. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable<int>), EqualityComparer<int>.Default));
  1835. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(IEqualityComparer<int>)));
  1836. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable<int>), x => x));
  1837. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func<int, int>)));
  1838. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(default(IAsyncEnumerable<int>), x => x, EqualityComparer<int>.Default));
  1839. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), default(Func<int, int>), EqualityComparer<int>.Default));
  1840. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.DistinctUntilChanged(AsyncEnumerable.Return(42), x => x, default(IEqualityComparer<int>)));
  1841. }
  1842. [Fact]
  1843. public void DistinctUntilChanged1()
  1844. {
  1845. var xs = new[] { 1, 2, 2, 3, 4, 4, 4, 4, 5, 6, 6, 7, 3, 2, 2, 1, 1 }.ToAsyncEnumerable().DistinctUntilChanged();
  1846. var e = xs.GetEnumerator();
  1847. HasNext(e, 1);
  1848. HasNext(e, 2);
  1849. HasNext(e, 3);
  1850. HasNext(e, 4);
  1851. HasNext(e, 5);
  1852. HasNext(e, 6);
  1853. HasNext(e, 7);
  1854. HasNext(e, 3);
  1855. HasNext(e, 2);
  1856. HasNext(e, 1);
  1857. NoNext(e);
  1858. }
  1859. [Fact]
  1860. public void DistinctUntilChanged2()
  1861. {
  1862. var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => (x + 1) / 2);
  1863. var e = xs.GetEnumerator();
  1864. HasNext(e, 1);
  1865. HasNext(e, 3);
  1866. HasNext(e, 5);
  1867. HasNext(e, 2);
  1868. NoNext(e);
  1869. }
  1870. [Fact]
  1871. public void DistinctUntilChanged3()
  1872. {
  1873. var ex = new Exception("Bang!");
  1874. var xs = new[] { 1, 2, 3, 4, 3, 5, 2 }.ToAsyncEnumerable().DistinctUntilChanged(x => { if (x == 4) throw ex; return x; });
  1875. var e = xs.GetEnumerator();
  1876. HasNext(e, 1);
  1877. HasNext(e, 2);
  1878. HasNext(e, 3);
  1879. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1880. }
  1881. [Fact]
  1882. public void Expand_Null()
  1883. {
  1884. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Expand(default(IAsyncEnumerable<int>), x => null));
  1885. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Expand(AsyncEnumerable.Return(42), null));
  1886. }
  1887. [Fact]
  1888. public void Expand1()
  1889. {
  1890. var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => AsyncEnumerable.Return(x - 1).Repeat(x - 1));
  1891. var e = xs.GetEnumerator();
  1892. HasNext(e, 2);
  1893. HasNext(e, 3);
  1894. HasNext(e, 1);
  1895. HasNext(e, 2);
  1896. HasNext(e, 2);
  1897. HasNext(e, 1);
  1898. HasNext(e, 1);
  1899. NoNext(e);
  1900. }
  1901. [Fact]
  1902. public void Expand2()
  1903. {
  1904. var ex = new Exception("Bang!");
  1905. var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => { throw ex; });
  1906. var e = xs.GetEnumerator();
  1907. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1908. }
  1909. [Fact]
  1910. public void Expand3()
  1911. {
  1912. var xs = new[] { 2, 3 }.ToAsyncEnumerable().Expand(x => null);
  1913. var e = xs.GetEnumerator();
  1914. HasNext(e, 2);
  1915. HasNext(e, 3);
  1916. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NullReferenceException);
  1917. }
  1918. [Fact]
  1919. public void Scan_Null()
  1920. {
  1921. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Scan(default(IAsyncEnumerable<int>), 3, (x, y) => x + y));
  1922. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), 3, null));
  1923. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Scan(default(IAsyncEnumerable<int>), (x, y) => x + y));
  1924. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Scan(AsyncEnumerable.Return(42), null));
  1925. }
  1926. [Fact]
  1927. public void Scan1()
  1928. {
  1929. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => x + y);
  1930. var e = xs.GetEnumerator();
  1931. HasNext(e, 9);
  1932. HasNext(e, 11);
  1933. HasNext(e, 14);
  1934. NoNext(e);
  1935. }
  1936. [Fact]
  1937. public void Scan2()
  1938. {
  1939. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => x + y);
  1940. var e = xs.GetEnumerator();
  1941. HasNext(e, 3);
  1942. HasNext(e, 6);
  1943. NoNext(e);
  1944. }
  1945. [Fact]
  1946. public void Scan3()
  1947. {
  1948. var ex = new Exception("Bang!");
  1949. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan(8, (x, y) => { throw ex; });
  1950. var e = xs.GetEnumerator();
  1951. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1952. }
  1953. [Fact]
  1954. public void Scan4()
  1955. {
  1956. var ex = new Exception("Bang!");
  1957. var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable().Scan((x, y) => { throw ex; });
  1958. var e = xs.GetEnumerator();
  1959. AssertThrows<Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
  1960. }
  1961. [Fact]
  1962. public void DistinctKey_Null()
  1963. {
  1964. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable<int>), x => x));
  1965. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null));
  1966. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(default(IAsyncEnumerable<int>), x => x, EqualityComparer<int>.Default));
  1967. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), null, EqualityComparer<int>.Default));
  1968. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Distinct(AsyncEnumerable.Return(42), x => x, null));
  1969. }
  1970. [Fact]
  1971. public void DistinctKey1()
  1972. {
  1973. var xs = new[] { 1, 2, 3, 4, 5 }.ToAsyncEnumerable().Distinct(x => x / 2);
  1974. var e = xs.GetEnumerator();
  1975. HasNext(e, 1);
  1976. HasNext(e, 2);
  1977. HasNext(e, 4);
  1978. NoNext(e);
  1979. }
  1980. [Fact]
  1981. public void TakeLast_Null()
  1982. {
  1983. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.TakeLast(default(IAsyncEnumerable<int>), 5));
  1984. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.TakeLast(AsyncEnumerable.Return(42), -1));
  1985. }
  1986. [Fact]
  1987. public void TakeLast1()
  1988. {
  1989. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(2);
  1990. var e = xs.GetEnumerator();
  1991. HasNext(e, 3);
  1992. HasNext(e, 4);
  1993. NoNext(e);
  1994. }
  1995. [Fact]
  1996. public void TakeLast2()
  1997. {
  1998. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(5);
  1999. var e = xs.GetEnumerator();
  2000. HasNext(e, 1);
  2001. HasNext(e, 2);
  2002. HasNext(e, 3);
  2003. HasNext(e, 4);
  2004. NoNext(e);
  2005. }
  2006. [Fact]
  2007. public void TakeLast_BugFix_TakeLast_Zero_TakesForever()
  2008. {
  2009. bool isSet = false;
  2010. new int[] { 1, 2, 3, 4 }.ToAsyncEnumerable()
  2011. .TakeLast(0)
  2012. .ForEachAsync(_ => { isSet = true; })
  2013. .Wait(WaitTimeoutMs);
  2014. Assert.False(isSet);
  2015. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().TakeLast(0);
  2016. var e = xs.GetEnumerator();
  2017. NoNext(e);
  2018. }
  2019. [Fact]
  2020. public void SkipLast_Null()
  2021. {
  2022. AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SkipLast(default(IAsyncEnumerable<int>), 5));
  2023. AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.SkipLast(AsyncEnumerable.Return(42), -1));
  2024. }
  2025. [Fact]
  2026. public void SkipLast1()
  2027. {
  2028. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(2);
  2029. var e = xs.GetEnumerator();
  2030. HasNext(e, 1);
  2031. HasNext(e, 2);
  2032. NoNext(e);
  2033. }
  2034. [Fact]
  2035. public void SkipLast2()
  2036. {
  2037. var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().SkipLast(5);
  2038. var e = xs.GetEnumerator();
  2039. NoNext(e);
  2040. }
  2041. }
  2042. }