FirstOrDefault.cs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343
  1. // Licensed to the .NET Foundation under one or more agreements.
  2. // The .NET Foundation licenses this file to you under the MIT License.
  3. // See the LICENSE file in the project root for more information.
  4. using System;
  5. using System.Linq;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  8. using Xunit;
  9. namespace Tests
  10. {
  11. public class FirstOrDefault : AsyncEnumerableTests
  12. {
  13. [Fact]
  14. public async Task FirstOrDefaultAsync_Null()
  15. {
  16. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default).AsTask());
  17. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, CancellationToken.None).AsTask());
  18. }
  19. [Fact]
  20. public async Task FirstOrDefaultAsync_NoParam_Empty()
  21. {
  22. var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAsync();
  23. Assert.Equal(0, await res);
  24. }
  25. [Fact]
  26. public async Task FirstOrDefaultAsync_NoParam_Empty_Enumerable()
  27. {
  28. var res = Array.Empty<int>().Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync();
  29. Assert.Equal(0, await res);
  30. }
  31. [Fact]
  32. public async Task FirstOrDefaultAsync_NoParam_Empty_IList()
  33. {
  34. var res = Array.Empty<int>().ToAsyncEnumerable().FirstOrDefaultAsync();
  35. Assert.Equal(0, await res);
  36. }
  37. [Fact]
  38. public async Task FirstOrDefaultAsync_NoParam_Throw()
  39. {
  40. var ex = new Exception("Bang!");
  41. var res = Throw<int>(ex).FirstOrDefaultAsync();
  42. await AssertThrowsAsync(res, ex);
  43. }
  44. [Fact]
  45. public async Task FirstOrDefaultAsync_NoParam_Single_IList()
  46. {
  47. var res = Return42.FirstOrDefaultAsync();
  48. Assert.Equal(42, await res);
  49. }
  50. [Fact]
  51. public async Task FirstOrDefaultAsync_NoParam_Single()
  52. {
  53. var res = new[] { 42 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync();
  54. Assert.Equal(42, await res);
  55. }
  56. [Fact]
  57. public async Task FirstOrDefaultAsync_NoParam_Many_IList()
  58. {
  59. var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync();
  60. Assert.Equal(42, await res);
  61. }
  62. [Fact]
  63. public async Task FirstOrDefaultAsync_NoParam_Many()
  64. {
  65. var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync();
  66. Assert.Equal(42, await res);
  67. }
  68. [Fact]
  69. public async Task FirstOrDefaultAsync_Predicate_Null()
  70. {
  71. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, x => true).AsTask());
  72. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, bool>)).AsTask());
  73. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, x => true, CancellationToken.None).AsTask());
  74. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default, CancellationToken.None).AsTask());
  75. }
  76. [Fact]
  77. public async Task FirstOrDefaultAsync_Predicate_Empty()
  78. {
  79. var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAsync(x => true);
  80. Assert.Equal(0, await res);
  81. }
  82. [Fact]
  83. public async Task FirstOrDefaultAsync_Predicate_Throw()
  84. {
  85. var ex = new Exception("Bang!");
  86. var res = Throw<int>(ex).FirstOrDefaultAsync(x => true);
  87. await AssertThrowsAsync(res, ex);
  88. }
  89. [Fact]
  90. public async Task FirstOrDefaultAsync_Predicate_Single_None()
  91. {
  92. var res = Return42.FirstOrDefaultAsync(x => x % 2 != 0);
  93. Assert.Equal(0, await res);
  94. }
  95. [Fact]
  96. public async Task FirstOrDefaultAsync_Predicate_Many_IList_None()
  97. {
  98. var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  99. Assert.Equal(0, await res);
  100. }
  101. [Fact]
  102. public async Task FirstOrDefaultAsync_Predicate_Many_None()
  103. {
  104. var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  105. Assert.Equal(0, await res);
  106. }
  107. [Fact]
  108. public async Task FirstOrDefaultAsync_Predicate_Single_Pass()
  109. {
  110. var res = Return42.FirstOrDefaultAsync(x => x % 2 == 0);
  111. Assert.Equal(42, await res);
  112. }
  113. [Fact]
  114. public async Task FirstOrDefaultAsync_Predicate_Many_IList_Pass1()
  115. {
  116. var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  117. Assert.Equal(43, await res);
  118. }
  119. [Fact]
  120. public async Task FirstOrDefaultAsync_Predicate_Many_IList_Pass2()
  121. {
  122. var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  123. Assert.Equal(45, await res);
  124. }
  125. [Fact]
  126. public async Task FirstOrDefaultAsync_Predicate_Many_Pass1()
  127. {
  128. var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  129. Assert.Equal(43, await res);
  130. }
  131. [Fact]
  132. public async Task FirstOrDefaultAsync_Predicate_Many_Pass2()
  133. {
  134. var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => x % 2 != 0);
  135. Assert.Equal(45, await res);
  136. }
  137. [Fact]
  138. public async Task FirstOrDefaultAsync_Predicate_PredicateThrows()
  139. {
  140. var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => 1 / x > 0);
  141. await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
  142. }
  143. [Fact]
  144. public async Task FirstOrDefaultAwaitAsync_Predicate_Null()
  145. {
  146. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
  147. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync(Return42, default).AsTask());
  148. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
  149. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync(Return42, default, CancellationToken.None).AsTask());
  150. }
  151. [Fact]
  152. public async Task FirstOrDefaultAwaitAsync_Predicate_Empty()
  153. {
  154. var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
  155. Assert.Equal(0, await res);
  156. }
  157. [Fact]
  158. public async Task FirstOrDefaultAwaitAsync_Predicate_Throw()
  159. {
  160. var ex = new Exception("Bang!");
  161. var res = Throw<int>(ex).FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
  162. await AssertThrowsAsync(res, ex);
  163. }
  164. [Fact]
  165. public async Task FirstOrDefaultAwaitAsync_Predicate_Single_None()
  166. {
  167. var res = Return42.FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  168. Assert.Equal(0, await res);
  169. }
  170. [Fact]
  171. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_None()
  172. {
  173. var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  174. Assert.Equal(0, await res);
  175. }
  176. [Fact]
  177. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_None()
  178. {
  179. var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  180. Assert.Equal(0, await res);
  181. }
  182. [Fact]
  183. public async Task FirstOrDefaultAwaitAsync_Predicate_Single_Pass()
  184. {
  185. var res = Return42.FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
  186. Assert.Equal(42, await res);
  187. }
  188. [Fact]
  189. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_Pass1()
  190. {
  191. var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  192. Assert.Equal(43, await res);
  193. }
  194. [Fact]
  195. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_Pass2()
  196. {
  197. var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  198. Assert.Equal(45, await res);
  199. }
  200. [Fact]
  201. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_Pass1()
  202. {
  203. var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  204. Assert.Equal(43, await res);
  205. }
  206. [Fact]
  207. public async Task FirstOrDefaultAwaitAsync_Predicate_Many_Pass2()
  208. {
  209. var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
  210. Assert.Equal(45, await res);
  211. }
  212. [Fact]
  213. public async Task FirstOrDefaultAwaitAsync_Predicate_AsyncPredicateThrows()
  214. {
  215. var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(1 / x > 0));
  216. await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
  217. }
  218. #if !NO_DEEP_CANCELLATION
  219. [Fact]
  220. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Null()
  221. {
  222. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
  223. await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
  224. }
  225. [Fact]
  226. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Empty()
  227. {
  228. var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
  229. Assert.Equal(0, await res);
  230. }
  231. [Fact]
  232. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Throw()
  233. {
  234. var ex = new Exception("Bang!");
  235. var res = Throw<int>(ex).FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
  236. await AssertThrowsAsync(res, ex);
  237. }
  238. [Fact]
  239. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Single_None()
  240. {
  241. var res = Return42.FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  242. Assert.Equal(0, await res);
  243. }
  244. [Fact]
  245. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_None()
  246. {
  247. var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  248. Assert.Equal(0, await res);
  249. }
  250. [Fact]
  251. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_None()
  252. {
  253. var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  254. Assert.Equal(0, await res);
  255. }
  256. [Fact]
  257. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Single_Pass()
  258. {
  259. var res = Return42.FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
  260. Assert.Equal(42, await res);
  261. }
  262. [Fact]
  263. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass1()
  264. {
  265. var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  266. Assert.Equal(43, await res);
  267. }
  268. [Fact]
  269. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass2()
  270. {
  271. var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  272. Assert.Equal(45, await res);
  273. }
  274. [Fact]
  275. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass1()
  276. {
  277. var res = new[] { 42, 43, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  278. Assert.Equal(43, await res);
  279. }
  280. [Fact]
  281. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass2()
  282. {
  283. var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
  284. Assert.Equal(45, await res);
  285. }
  286. [Fact]
  287. public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_AsyncPredicateWithCancellationThrows()
  288. {
  289. var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
  290. await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
  291. }
  292. #endif
  293. }
  294. }