PageRenderTime 57ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/mcs/class/System.Core/Test/System.Linq/EnumerableFixture.cs

https://bitbucket.org/steenlund/mono-2.6.7-for-amiga
C# | 2292 lines | 1902 code | 356 blank | 34 comment | 45 complexity | 52401e08a1e115f484437c8c11bfa4ef MD5 | raw file
Possible License(s): LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

  1. #region License, Terms and Author(s)
  2. //
  3. // BackLINQ
  4. // Copyright (c) 2008 Atif Aziz. All rights reserved.
  5. //
  6. // Author(s):
  7. //
  8. // Dominik Hug, http://www.dominikhug.ch
  9. //
  10. // This library is free software; you can redistribute it and/or modify it
  11. // under the terms of the New BSD License, a copy of which should have
  12. // been delivered along with this distribution.
  13. //
  14. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  15. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  16. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  17. // PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  18. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  20. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. //
  26. #endregion
  27. using System;
  28. using System.Collections;
  29. using System.Collections.Generic;
  30. using System.Globalization;
  31. using System.Text;
  32. using System.Threading;
  33. using NUnit.Framework;
  34. using System.Linq;
  35. using NUnit.Framework.SyntaxHelpers;
  36. using NUnit.Framework.Constraints;
  37. using System.Diagnostics;
  38. namespace MonoTests.System.Linq
  39. {
  40. [TestFixture]
  41. public sealed class EnumerableFixture {
  42. private CultureInfo initialCulture; // Thread culture saved during Setup to be undone in TearDown.
  43. private AssertionHandler tearDownAssertions;
  44. private delegate void AssertionHandler ();
  45. [SetUp]
  46. public void SetUp ()
  47. {
  48. tearDownAssertions = null;
  49. initialCulture = Thread.CurrentThread.CurrentCulture;
  50. Thread.CurrentThread.CurrentCulture = new CultureInfo ("de-CH");
  51. }
  52. [TearDown]
  53. public void TearDown ()
  54. {
  55. if (tearDownAssertions != null)
  56. tearDownAssertions ();
  57. Thread.CurrentThread.CurrentCulture = initialCulture;
  58. }
  59. [Test]
  60. [ExpectedException (typeof (InvalidOperationException))]
  61. public void Aggregate_EmptySource_ThrowsInvalidOperationException ()
  62. {
  63. var source = Read<object> ();
  64. source.Aggregate (delegate { throw new NotImplementedException (); });
  65. }
  66. [Test]
  67. public void Aggregate_AddFuncOnIntegers_ReturnsTotal ()
  68. {
  69. var source = Read (12, 34, 56, 78, 910, 1112, 1314, 1516, 1718, 1920);
  70. var result = source.Aggregate ((a, b) => a + b);
  71. Assert.That (result, Is.EqualTo (8670));
  72. }
  73. [Test]
  74. public void Aggregate_AddFuncOnIntegersWithSeed_ReturnsTotal ()
  75. {
  76. var source = Read (12, 34, 56, 78, 910, 1112, 1314, 1516, 1718, 1920);
  77. var result = source.Aggregate (100, (a, b) => a + b);
  78. Assert.That (result, Is.EqualTo (8770));
  79. }
  80. [Test]
  81. [ExpectedException (typeof (ArgumentNullException))]
  82. public void Aggregate_NullSource_ThrowsArgumentNullException ()
  83. {
  84. Enumerable.Aggregate<object> (null, delegate { throw new NotImplementedException (); });
  85. }
  86. [Test]
  87. [ExpectedException (typeof (ArgumentNullException))]
  88. public void Aggregate_NullFunc_ThrowsArgumentNullException ()
  89. {
  90. Read<object> ().Aggregate (null);
  91. }
  92. [Test]
  93. public void Empty_YieldsEmptySource ()
  94. {
  95. var source = Enumerable.Empty<string> ();
  96. Assert.That (source, Is.Not.Null);
  97. var e = source.GetEnumerator ();
  98. Assert.That (e, Is.Not.Null);
  99. Assert.That (e.MoveNext (), Is.False);
  100. }
  101. [Test]
  102. [ExpectedException (typeof (ArgumentNullException))]
  103. public void Cast_NullSource_ThrowsArgumentNullException ()
  104. {
  105. Enumerable.Cast<object> (null);
  106. }
  107. [Test]
  108. [ExpectedException (typeof (InvalidCastException))]
  109. public void Cast_InvalidSource_ThrowsInvalidCastException ()
  110. {
  111. var source = Read (1000, "hello", new object ());
  112. var e = source.Cast<byte> ().GetEnumerator ();
  113. e.MoveNext (); // Do something so Cast will really run (deferred execution)
  114. }
  115. [Test]
  116. public void Cast_ObjectSourceContainingIntegers_YieldsDowncastedIntegers ()
  117. {
  118. var source = Read<object> (1, 10, 100);
  119. source.Cast<int> ().AssertEquals (1, 10, 100);
  120. }
  121. [Test]
  122. public void Cast_Integers_YieldsUpcastedObjects ()
  123. {
  124. #if false
  125. // shouldn't this be inferred?
  126. Read (1, 10, 100).Cast<object> ().AssertEquals (1, 10, 100);
  127. #else
  128. Read (1, 10, 100).Cast<object> ().AssertEquals<object> (1, 10, 100);
  129. #endif
  130. }
  131. [Test]
  132. [ExpectedException (typeof (ArgumentNullException))]
  133. public void All_NullSource_ThrowsArgumentNullException ()
  134. {
  135. Enumerable.All (null, (int i) => { throw new NotImplementedException (); });
  136. }
  137. [Test]
  138. public void All_SomeSourceElementsNotSatifyingPredicate_ReturnsFalse ()
  139. {
  140. var source = Read (-100, -1, 0, 1, 100);
  141. Assert.That (source.All (i => i < 0), Is.False);
  142. }
  143. [Test]
  144. public void All_SourceElementsSatisfyingPredicate_ReturnsTrue ()
  145. {
  146. var source = Read (-100, -1, 0, 1, 100);
  147. Assert.That (source.All (i => i >= -100), Is.True);
  148. }
  149. [Test]
  150. [ExpectedException (typeof (ArgumentNullException))]
  151. public void Any_NullSource_ThrowsArgumentNullException ()
  152. {
  153. Enumerable.Any<object> (null);
  154. }
  155. [Test]
  156. public void Any_EmptySource_ReturnsFalse ()
  157. {
  158. var source = Read<object> ();
  159. Assert.That (source.Any (), Is.False);
  160. }
  161. [Test]
  162. public void Any_NonEmptySource_ReturnsTrue ()
  163. {
  164. var source = Read (new object ());
  165. Assert.That (source.Any (), Is.True);
  166. }
  167. [Test]
  168. public void Any_PredicateArg_EmptySource_ReturnsFalse ()
  169. {
  170. var source = Read (new int [0]);
  171. Assert.That (source.Any (delegate { throw new NotImplementedException (); }), Is.False);
  172. }
  173. [Test]
  174. public void Any_PredicateArg_NonEmptySource_ReturnsTrue ()
  175. {
  176. Assert.That (Read (1, 2, 3, 4, 5).Any (i => i > 2), Is.True);
  177. }
  178. [Test]
  179. [ExpectedException (typeof (InvalidOperationException))]
  180. public void Average_EmptyLongSource_ThrowsInvalidOperationException ()
  181. {
  182. Read<long> ().Average ();
  183. }
  184. [Test]
  185. public void Average_Longs_ReturnsAverage ()
  186. {
  187. Assert.That (Read (25L, 75L).Average (), Is.EqualTo (50));
  188. }
  189. [Test]
  190. public void Average_SelectorArg_Longs_ReturnsAverage ()
  191. {
  192. Assert.That (Read (25L, 75L).Average (n => n * 2L), Is.EqualTo (100));
  193. }
  194. [Test]
  195. public void Average_EmptyNullableLongSource_Null ()
  196. {
  197. Assert.That (Read<long?> ().Average (), Is.Null);
  198. }
  199. [Test]
  200. public void Average_NullableLongsWithSomeNull_ReturnsAverage ()
  201. {
  202. Assert.That (Read<long?> (12L, null, 34L, null, 56L).Average (), Is.EqualTo (34.0));
  203. }
  204. [Test]
  205. public void Average_SelectorArg_NullableLongsWithSomeNull_ReturnsAverage ()
  206. {
  207. Assert.That (Read<long?> (12L, null, 34L, null, 56L).Average (n => n * 2L), Is.EqualTo (68.0));
  208. }
  209. [Test]
  210. public void Average_EmptyNullableIntegerSource_Null ()
  211. {
  212. Assert.That (Read<int?> ().Average (), Is.Null);
  213. }
  214. [Test]
  215. public void Average_NullableIntegersWithSomeNull_ReturnsAverage ()
  216. {
  217. Assert.That (Read<int?> (12, null, 34, null, 56).Average (), Is.EqualTo (34.0));
  218. }
  219. [Test]
  220. public void Average_SelectorArg_NullableIntegersWithSomeNull_ReturnsAverage ()
  221. {
  222. Assert.That (Read<int?> (12, null, 34, null, 56).Average (n => n * 2), Is.EqualTo (68.0));
  223. }
  224. [Test]
  225. [ExpectedException (typeof (InvalidOperationException))]
  226. public void Average_EmptyDecimalSource_ThrowsInvalidOperationException ()
  227. {
  228. Read<decimal> ().Average ();
  229. }
  230. [Test]
  231. public void Average_Decimals_ReturnsAverage ()
  232. {
  233. var source = Read (-10000m, 2.0001m, 50m);
  234. Assert.That (source.Average (), Is.EqualTo (-3315.999966).Within (0.00001));
  235. }
  236. [Test]
  237. public void Average_SelectorArg_Decimals_ReturnsAverage ()
  238. {
  239. var source = Read (-10000m, 2.0001m, 50m);
  240. Assert.That (source.Average (n => n * 2m), Is.EqualTo (-6631.999933).Within (0.00001));
  241. }
  242. [Test]
  243. [ExpectedException (typeof (InvalidOperationException))]
  244. public void Average_EmptySource_ThrowsInvalidOperationException ()
  245. {
  246. Read<int> ().Average ();
  247. }
  248. [Test]
  249. public void Average_EmptyNullableIntegerSource_ReturnsNull ()
  250. {
  251. Assert.That (Read<int?> ().Average (), Is.Null);
  252. }
  253. [Test]
  254. public void Average_SelectorArg_Integers_ReturnsAverage ()
  255. {
  256. Assert.That (Read (21, 22, 23, 24).Average (n => n * 2).Equals (45));
  257. }
  258. [Test]
  259. [ExpectedException (typeof (InvalidOperationException))]
  260. public void Average_EmptyDoubleSource_ThrowsInvalidOperationException ()
  261. {
  262. Read<double> ().Average ();
  263. }
  264. [Test]
  265. public void Average_Doubles_ReturnsAverage ()
  266. {
  267. var source = Read (-3.45, 9.001, 10000.01);
  268. Assert.That (source.Average (), Is.EqualTo (3335.187).Within (0.01));
  269. }
  270. [Test]
  271. public void Average_SelectorArg_Doubles_ReturnsAverage ()
  272. {
  273. var source = Read (-3.45, 9.001, 10000.01);
  274. Assert.That (source.Average (n => n * 2.0), Is.EqualTo (6670.374).Within (0.01));
  275. }
  276. [Test]
  277. [ExpectedException (typeof (InvalidOperationException))]
  278. public void Average_EmptyFloatSource_ThrowsInvalidOperationException ()
  279. {
  280. Read<float> ().Average ();
  281. }
  282. [Test]
  283. public void Average_Floats_ReturnsAverage ()
  284. {
  285. var source = Read (-3.45F, 9.001F, 10000.01F);
  286. Assert.That (source.Average (), Is.EqualTo (3335.187).Within (0.01));
  287. }
  288. [Test]
  289. public void Average_SelectorArg_Floats_ReturnsAverage ()
  290. {
  291. var source = Read (-3.45F, 9.001F, 10000.01F);
  292. Assert.That (source.Average (n => n * 2F), Is.EqualTo (6670.37354).Within (0.01));
  293. }
  294. [Test]
  295. public void Average_EmptyNullableFloatSource_Null ()
  296. {
  297. Assert.That (Read<float?> ().Average (), Is.Null);
  298. }
  299. [Test]
  300. public void Average_NullableFloatsWithSomeNulls_ReturnsAverage ()
  301. {
  302. var source = Read<float?> (-3.45F, null, 9.001F, null, 10000.01F);
  303. Assert.That (source.Average (), Is.EqualTo (3335.187).Within (0.01));
  304. }
  305. [Test]
  306. public void Average_SelectorArg_NullableFloatsWithSomeNulls_ReturnsAverage ()
  307. {
  308. var source = Read<float?> (-3.45F, null, 9.001F, null, 10000.01F);
  309. Assert.That (source.Average (n => n * 2F), Is.EqualTo (6670.37354).Within (0.01));
  310. }
  311. [Test]
  312. public void Average_EmptyNullableDoubleSource_Null ()
  313. {
  314. Assert.That (Read<double?> ().Average (), Is.Null);
  315. }
  316. [Test]
  317. public void Average_NullableDoublesWithSomeNulls_ReturnsAverage ()
  318. {
  319. var source = Read<double?> (-3.45, null, 9.001, null, 10000.01);
  320. Assert.That (source.Average (), Is.EqualTo (3335.187).Within (0.01));
  321. }
  322. [Test]
  323. public void Average_SelectorArg_NullableDoublesWithSomeNulls_ReturnsAverage ()
  324. {
  325. var source = Read<double?> (-3.45, null, 9.001, null, 10000.01);
  326. Assert.That (source.Average (n => n * 2.0), Is.EqualTo (6670.374).Within (0.01));
  327. }
  328. [Test]
  329. public void Average_EmptyNullableDecimalSource_Null ()
  330. {
  331. Assert.That (Read<decimal?> ().Average (), Is.Null);
  332. }
  333. [Test]
  334. public void Average_NullableDecimalsWithSomeNulls_ReturnsAverage ()
  335. {
  336. var source = Read<decimal?> (-3.45m, null, 9.001m, null, 10000.01m);
  337. Assert.That (source.Average (), Is.EqualTo (3335.187).Within (0.01));
  338. }
  339. [Test]
  340. public void Average_SelectorArg_NullableDecimalsWithSomeNulls_ReturnsAverage ()
  341. {
  342. var source = Read<decimal?> (-3.45m, null, 9.001m, null, 10000.01m);
  343. Assert.That (source.Average (n => n * 2m), Is.EqualTo (6670.374m).Within (0.01));
  344. }
  345. [Test]
  346. [ExpectedException (typeof (ArgumentNullException))]
  347. public void Concat_FirstSourceNull_ThrowsArgumentNullException ()
  348. {
  349. Enumerable.Concat (null, new object [0]);
  350. }
  351. [Test]
  352. [ExpectedException (typeof (ArgumentNullException))]
  353. public void Concat_SecondSourceNull_ThrowsArgumentNullException ()
  354. {
  355. new object [0].Concat (null);
  356. }
  357. [Test]
  358. public void Concat_TwoSequences_CombinedSequenceWhereElementsOfSecondFollowFirst ()
  359. {
  360. var first = Read (12, 34, 56);
  361. var second = Read (78, 910, 1112);
  362. first.Concat (second).AssertEquals (12, 34, 56, 78, 910, 1112);
  363. }
  364. [Test]
  365. public void Contains_SequenceContainingSoughtValue_ReturnsTrue ()
  366. {
  367. var source = Read (12, -15, 21);
  368. Assert.That (source.Contains (21), Is.True);
  369. }
  370. [Test]
  371. public void Contains_SequenceWithoutSoughtValue_ReturnsFalse ()
  372. {
  373. var source = Read (-2, 4, 8);
  374. Assert.That (source.Contains (9), Is.False);
  375. }
  376. [Test]
  377. public void Contains_CollectionOptimization_ReturnsTrueWithoutEnumerating ()
  378. {
  379. var source = new NonEnumerableList<int> (new [] { 1, 2, 3 });
  380. // IMPORTANT! Use the non-extension invocation style below
  381. // to avoid calling List<T>.Contains instead of
  382. // Enumerable.Contains.
  383. Assert.That (Enumerable.Contains (source, 3), Is.True);
  384. }
  385. [Test]
  386. public void Count_Integers_ReturnsNumberOfElements ()
  387. {
  388. Assert.That (Read (12, 34, 56).Count (), Is.EqualTo (3));
  389. }
  390. [Test]
  391. public void Count_PredicateArg_Strings_CountsOnlyStringsWithEvenLength ()
  392. {
  393. var source = Read ("A", "AB", "ABC", "ABCD");
  394. Assert.That (source.Count (s => s.Length % 2 == 0), Is.EqualTo (2));
  395. }
  396. [Test]
  397. public void DefaultIfEmpty_Integers_YieldsIntegersInOrder ()
  398. {
  399. var source = Read (12, 34, 56);
  400. source.DefaultIfEmpty (1).AssertEquals (12, 34, 56);
  401. }
  402. [Test]
  403. public void DefaultIfEmpty_EmptyIntegerSequence_ReturnsZero ()
  404. {
  405. var source = Read (new int [0]);
  406. source.DefaultIfEmpty ().AssertEquals (0);
  407. }
  408. [Test]
  409. public void DefaultIfEmpty_DefaultValueArg_EmptyIntegerSequenceAndNonZeroDefault_ReturnNonZeroDefault ()
  410. {
  411. var source = Read (new int [0]);
  412. source.DefaultIfEmpty (5).AssertEquals (5);
  413. }
  414. [Test]
  415. public void DefaultIfEmpty_DefaultValueArg_Integers_YieldsIntegersInOrder ()
  416. {
  417. var source = Read (12, 34, 56);
  418. source.DefaultIfEmpty (5).AssertEquals (12, 34, 56);
  419. }
  420. [Test]
  421. [ExpectedException (typeof (ArgumentNullException))]
  422. public void Distinct_NullSource_ThrowsArgumentNullException ()
  423. {
  424. Enumerable.Distinct<object> (null);
  425. }
  426. [Test]
  427. public void Distinct_IntegersWithSomeDuplicates_YieldsIntegersInSourceOrderWithoutDuplicates ()
  428. {
  429. var source = Read (12, 34, 34, 56, 78, 78, 78, 910, 78);
  430. source.Distinct ().AssertEquals (12, 34, 56, 78, 910);
  431. }
  432. [Test]
  433. public void Distinct_MixedCaseStringsWithCaseIgnoringComparer_YieldsFirstCaseOfEachDistinctStringInSourceOrder ()
  434. {
  435. var source = Read ("Foo Bar BAZ BaR baz FOo".Split ());
  436. source.Distinct (StringComparer.InvariantCultureIgnoreCase).AssertEquals ("Foo", "Bar", "BAZ");
  437. }
  438. [Test]
  439. [ExpectedException (typeof (ArgumentOutOfRangeException))]
  440. public void ElementAt_IndexOutOfRange_ThrowsArgumentOutOfRangeException ()
  441. {
  442. var source = Read (3, 5, 7);
  443. source.ElementAt (3);
  444. }
  445. [Test]
  446. public void ElementAt_Integers_ReturnsValueAtGivenIndex ()
  447. {
  448. var source = new [] { 15, 2, 7 };
  449. Assert.That (Read (source).ElementAt (0), Is.EqualTo (15));
  450. Assert.That (Read (source).ElementAt (1), Is.EqualTo (2));
  451. Assert.That (Read (source).ElementAt (2), Is.EqualTo (7));
  452. }
  453. [Test]
  454. [ExpectedException (typeof (ArgumentOutOfRangeException))]
  455. public void ElementAt_NegativeIndex_ThrowsArgumentOutOfRangeException ()
  456. {
  457. Read<int> ().ElementAt (-1);
  458. }
  459. [Test]
  460. public void ElementAt_ListOptimization_ReturnsValueAtGivenIndex ()
  461. {
  462. var source = new NonEnumerableList<int> (new [] { 1, 2, 3, 4, 5, 6 });
  463. Assert.That (source.ElementAt (2), Is.EqualTo (3));
  464. }
  465. [Test]
  466. public void ElementAtOrDefault_IntegersWithOutOfRangeIndex_ReturnsDefault ()
  467. {
  468. var source = Read (3, 6, 8);
  469. Assert.That (source.ElementAtOrDefault (3), Is.EqualTo (0));
  470. }
  471. [Test]
  472. public void ElementAtOrDefault_Integers_ReturnsValueAtGivenIndex ()
  473. {
  474. var source = Read (3, 6, 9);
  475. Assert.That (source.ElementAtOrDefault (2), Is.EqualTo (9));
  476. }
  477. [Test]
  478. public void ElementAtOrDefault_ListOptimization_ReturnsValueAtGivenIndex ()
  479. {
  480. var source = new NonEnumerableList<int> (new [] { 1, 2, 3, 4, 5, 6 });
  481. Assert.That (source.ElementAtOrDefault (2), Is.EqualTo (3));
  482. }
  483. [Test]
  484. public void ElementAtOrDefault_BooleansAndNegativeIndex_ReturnsDefault ()
  485. {
  486. var source = Read (true, false, true, false);
  487. Assert.That (source.ElementAtOrDefault (-3), Is.False);
  488. }
  489. [Test]
  490. public void ElementAtOrDefault_ObjectsWithOutOfRangeIndex_ReturnsNull ()
  491. {
  492. var source = Read (new object (), new object ());
  493. Assert.That (source.ElementAtOrDefault (2), Is.EqualTo (null));
  494. }
  495. [Test]
  496. public void ElementAtOrDefault_Objects_ReturnsValueAtGivenIndex ()
  497. {
  498. var second = new object ();
  499. var source = Read (new object (), second, new object ());
  500. Assert.That (source.ElementAt (1), Is.EqualTo (second));
  501. }
  502. [Test]
  503. [ExpectedException (typeof (ArgumentNullException))]
  504. public void Except_SecondArg_ArgumentNull_ThrowsArgumentNullException ()
  505. {
  506. Read<object> ().Except (null);
  507. }
  508. [Test]
  509. public void Except_SecondArg_ValidArgument_ReturnsDifference ()
  510. {
  511. var first = Read (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  512. var second = Read (1, 3, 5, 7, 9);
  513. first.Except (second).AssertEquals (2, 4, 6, 8, 10);
  514. }
  515. [Test]
  516. public void Except_SecondArgComparerArg_ComparerIsUsed ()
  517. {
  518. var first = Read ("albert", "john", "simon");
  519. var second = Read ("ALBERT");
  520. first.Except (second, StringComparer.CurrentCultureIgnoreCase).AssertEquals ("john", "simon");
  521. }
  522. [Test]
  523. [ExpectedException (typeof (InvalidOperationException))]
  524. public void First_EmptySource_ThrowsInvalidOperationException ()
  525. {
  526. Read<int> ().First ();
  527. }
  528. [Test]
  529. public void First_Integers_ReturnsFirst ()
  530. {
  531. var source = Read (12, 34, 56);
  532. Assert.That (source.First (), Is.EqualTo (12));
  533. }
  534. [Test]
  535. public void First_IntegersWithPredicateForEvens_FirstEvenInteger ()
  536. {
  537. var source = Read (15, 20, 25, 30);
  538. Assert.That (source.First (i => i % 2 == 0), Is.EqualTo (20));
  539. }
  540. [Test]
  541. [ExpectedException (typeof (InvalidOperationException))]
  542. public void First_IntegerSequenceWithNoneMatchingPredicate_ThrowsInvalidOperationException ()
  543. {
  544. var source = Read (12, 34, 56, 78);
  545. Assert.That (source.First (i => i > 100), Is.EqualTo (0));
  546. }
  547. [Test]
  548. public void FirstOrDefault_EmptyBooleanSource_ReturnsFalse ()
  549. {
  550. Assert.That (Read<bool> ().FirstOrDefault (), Is.False);
  551. }
  552. [Test]
  553. public void FirstOrDefault_Objects_ReturnsFirstReference ()
  554. {
  555. var first = new object ();
  556. var source = Read (first, new object ());
  557. Assert.That (source.FirstOrDefault (), Is.SameAs (first));
  558. }
  559. [Test]
  560. [ExpectedException (typeof (ArgumentNullException))]
  561. public void FirstOrDefault_PredicateArg_NullPredicate_ThrowsArgumentNullException ()
  562. {
  563. Read<int> ().FirstOrDefault (null);
  564. }
  565. [Test]
  566. public void FirstOrDefault_PredicateArg_NonNullPredicate_ReturnsFirstMatchingItem ()
  567. {
  568. var source = Read (1, 4, 8);
  569. Assert.That (source.FirstOrDefault (i => i % 2 == 0), Is.EqualTo (4));
  570. }
  571. [Test]
  572. public void FirstOrDefault_PredicateArg_IntegerSequenceWithNonMatchingPredicate_ReturnsDefaultValue ()
  573. {
  574. var source = Read (1, 4, 6);
  575. Assert.That (source.FirstOrDefault (i => i > 10), Is.EqualTo (0));
  576. }
  577. [Test]
  578. public void First_IntegerListOptimization_ReturnsFirstElementWithoutEnumerating ()
  579. {
  580. var source = new NonEnumerableList<int> (new [] { 123, 456, 789 });
  581. Assert.That (source.First (), Is.EqualTo (123));
  582. }
  583. private class Person {
  584. public string FirstName { get; set; }
  585. public string LastName { get; set; }
  586. public int Age { get; set; }
  587. public static Person [] CreatePersons ()
  588. {
  589. return new []
  590. {
  591. new Person { LastName = "M\u00FCller", FirstName = "Peter", Age = 21 },
  592. new Person { LastName = "M\u00FCller", FirstName = "Herbert", Age = 22 },
  593. new Person { LastName = "Meier", FirstName = "Hubert", Age = 23 },
  594. new Person { LastName = "Meier", FirstName = "Isidor", Age = 24 }
  595. };
  596. }
  597. public static Person [] CreatePersonsWithNamesUsingMixedCase ()
  598. {
  599. var persons = CreatePersons ();
  600. var herbert = persons [1];
  601. herbert.LastName = herbert.LastName.ToLower ();
  602. var isidor = persons [3];
  603. isidor.LastName = isidor.LastName.ToLower ();
  604. return persons;
  605. }
  606. }
  607. [Test]
  608. [ExpectedException (typeof (ArgumentNullException))]
  609. public void GroupBy_KeySelectorArg_NullAsKeySelector_ThrowsArgumentNullException ()
  610. {
  611. Read<object> ().GroupBy<object, object> (null);
  612. }
  613. [Test]
  614. public void GroupBy_KeySelectorArg_ValidArguments_CorrectGrouping ()
  615. {
  616. var persons = Read (Person.CreatePersons ());
  617. var result = new Reader<IGrouping<string, Person>> (persons.GroupBy (person => person.LastName));
  618. var group1 = result.Read ();
  619. Assert.That (group1.Key, Is.EqualTo ("M\u00FCller"));
  620. var muellers = new Reader<Person> (group1);
  621. Assert.That (muellers.Read ().FirstName, Is.EqualTo ("Peter"));
  622. Assert.That (muellers.Read ().FirstName, Is.EqualTo ("Herbert"));
  623. var group2 = result.Read ();
  624. Assert.That (group2.Key, Is.EqualTo ("Meier"));
  625. var meiers = new Reader<Person> (group2);
  626. Assert.That (meiers.Read ().FirstName, Is.EqualTo ("Hubert"));
  627. Assert.That (meiers.Read ().FirstName, Is.EqualTo ("Isidor"));
  628. result.AssertEnded ();
  629. }
  630. [Test]
  631. public void GroupBy_KeySelectorArg_ValidArguments_CorrectCaseSensitiveGrouping ()
  632. {
  633. var persons = Read (Person.CreatePersonsWithNamesUsingMixedCase ());
  634. var result = persons.GroupBy (person => person.LastName);
  635. var e = result.GetEnumerator ();
  636. Func<IGrouping<string, Person>, Person> first = g => new Reader<Person> (g).Read ();
  637. e.MoveNext ();
  638. Assert.That (e.Current.Key, Is.EqualTo ("M\u00FCller"));
  639. Assert.That (first (e.Current).FirstName, Is.EqualTo ("Peter"));
  640. e.MoveNext ();
  641. Assert.That (e.Current.Key, Is.EqualTo ("m\u00FCller"));
  642. Assert.That (first (e.Current).FirstName, Is.EqualTo ("Herbert"));
  643. e.MoveNext ();
  644. Assert.That (e.Current.Key, Is.EqualTo ("Meier"));
  645. Assert.That (first (e.Current).FirstName, Is.EqualTo ("Hubert"));
  646. e.MoveNext ();
  647. Assert.That (e.Current.Key, Is.EqualTo ("meier"));
  648. Assert.That (first (e.Current).FirstName, Is.EqualTo ("Isidor"));
  649. Assert.That (e.MoveNext (), Is.False);
  650. }
  651. [Test]
  652. public void GroupBy_KeySelectorArgComparerArg_KeysThatDifferInCasingNonCaseSensitiveStringComparer_CorrectGrouping ()
  653. {
  654. var persons = Read (Person.CreatePersonsWithNamesUsingMixedCase ());
  655. var result = new Reader<IGrouping<string, Person>> (
  656. persons.GroupBy (person => person.LastName, StringComparer.CurrentCultureIgnoreCase));
  657. var group1 = result.Read ();
  658. Assert.That (group1.Key, Is.EqualTo ("M\u00FCller"));
  659. var muellers = new Reader<Person> (group1);
  660. Assert.That (muellers.Read ().FirstName, Is.EqualTo ("Peter"));
  661. Assert.That (muellers.Read ().FirstName, Is.EqualTo ("Herbert"));
  662. var group2 = result.Read ();
  663. Assert.That (group2.Key, Is.EqualTo ("Meier"));
  664. var meiers = new Reader<Person> (group2);
  665. Assert.That (meiers.Read ().FirstName, Is.EqualTo ("Hubert"));
  666. Assert.That (meiers.Read ().FirstName, Is.EqualTo ("Isidor"));
  667. result.AssertEnded ();
  668. }
  669. [Test]
  670. public void GroupBy_KeySelectorArgElementSelectorArg_ValidArguments_CorrectGroupingAndProjection ()
  671. {
  672. var persons = Read (Person.CreatePersons ());
  673. var result = new Reader<IGrouping<string, int>> (
  674. persons.GroupBy (person => person.LastName, person => person.Age));
  675. var group1 = result.Read ();
  676. Assert.That (group1.Key, Is.EqualTo ("M\u00FCller"));
  677. var muellers = new Reader<int> (group1);
  678. Assert.That (muellers.Read (), Is.EqualTo (21));
  679. Assert.That (muellers.Read (), Is.EqualTo (22));
  680. var group2 = result.Read ();
  681. Assert.That (group2.Key, Is.EqualTo ("Meier"));
  682. var meiers = new Reader<int> (group2);
  683. Assert.That (meiers.Read (), Is.EqualTo (23));
  684. Assert.That (meiers.Read (), Is.EqualTo (24));
  685. }
  686. [Test]
  687. public void GroupBy_KeySelectorArgResultSelectorArg_ValidArguments_CorrectGroupingProcessing ()
  688. {
  689. var persons = Read (Person.CreatePersons ());
  690. var result = persons.GroupBy (
  691. p => p.LastName,
  692. (key, group) => {
  693. var total = 0;
  694. foreach (var p in group)
  695. total += p.Age;
  696. return key + ":" + total;
  697. });
  698. result.AssertEquals ("M\u00FCller:43", "Meier:47");
  699. }
  700. [Test]
  701. public void GroupBy_KeySelectorArgElementSelectorArgComparerArg_ValidArguments_CorrectGroupingAndProcessing ()
  702. {
  703. var persons = Read (Person.CreatePersonsWithNamesUsingMixedCase ());
  704. var result = new Reader<IGrouping<string, int>> (
  705. persons.GroupBy (p => p.LastName, p => p.Age, StringComparer.CurrentCultureIgnoreCase));
  706. var group1 = result.Read ();
  707. Assert.That (group1.Key, Is.EqualTo ("M\u00FCller"));
  708. var muellers = new Reader<int> (group1);
  709. Assert.That (muellers.Read (), Is.EqualTo (21));
  710. Assert.That (muellers.Read (), Is.EqualTo (22));
  711. var group2 = result.Read ();
  712. Assert.That (group2.Key, Is.EqualTo ("Meier"));
  713. var meiers = new Reader<int> (group2);
  714. Assert.That (meiers.Read (), Is.EqualTo (23));
  715. Assert.That (meiers.Read (), Is.EqualTo (24));
  716. }
  717. [Test]
  718. public void GroupBy_KeySelectorArgElementSelectorArgResultSelectorArg_ValidArguments_CorrectGroupingAndTransforming ()
  719. {
  720. var persons = Read (Person.CreatePersons ());
  721. var result = persons.GroupBy (
  722. p => p.LastName,
  723. p => p.Age,
  724. (key, ages) => {
  725. var total = 0;
  726. foreach (var age in ages)
  727. total += age;
  728. return key + ":" + total;
  729. });
  730. result.AssertEquals ("M\u00FCller:43", "Meier:47");
  731. }
  732. [Test]
  733. public void GroupBy_KeySelectorArgResultSelectorArgComparerArg_ValidArguments_CorrectGroupingAndTransforming ()
  734. {
  735. var persons = Read (Person.CreatePersonsWithNamesUsingMixedCase ());
  736. var result = persons.GroupBy (
  737. p => p.LastName,
  738. (key, values) => {
  739. var total = 0;
  740. foreach (var person in values)
  741. total += person.Age;
  742. return key + ":" + total;
  743. },
  744. StringComparer.CurrentCultureIgnoreCase);
  745. result.AssertEquals ("M\u00FCller:43", "Meier:47");
  746. }
  747. [Test]
  748. public void GroupBy_KeySelectorArgElementSelectorArgResultSelectorArgComparerArg_ValidArguments_CorrectGroupingAndTransforming ()
  749. {
  750. var persons = Read (Person.CreatePersonsWithNamesUsingMixedCase ());
  751. var result = persons.GroupBy (
  752. p => p.LastName,
  753. p => p.Age,
  754. (key, ages) => {
  755. var total = 0;
  756. foreach (var age in ages)
  757. total += age;
  758. return key + ":" + total;
  759. },
  760. StringComparer.CurrentCultureIgnoreCase);
  761. result.AssertEquals ("M\u00FCller:43", "Meier:47");
  762. }
  763. class Pet {
  764. public string Name { get; set; }
  765. public string Owner { get; set; }
  766. }
  767. [Test]
  768. public void GroupJoin_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArg_ValidArguments_CorrectGroupingAndJoining ()
  769. {
  770. var persons = Read (Person.CreatePersons ());
  771. var barley = new Pet { Name = "Barley", Owner = "Peter" };
  772. var boots = new Pet { Name = "Boots", Owner = "Herbert" };
  773. var whiskers = new Pet { Name = "Whiskers", Owner = "Herbert" };
  774. var daisy = new Pet { Name = "Daisy", Owner = "Isidor" };
  775. var pets = Read (barley, boots, whiskers, daisy);
  776. var result = persons.GroupJoin (pets, person => person.FirstName, pet => pet.Owner,
  777. (person, ppets) => new { Owner = person, Pets = ppets });
  778. using (var e = result.GetEnumerator ()) {
  779. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Peter"));
  780. e.Current.Pets.AssertThat (Is.SameAs, barley);
  781. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Herbert"));
  782. e.Current.Pets.AssertThat (Is.SameAs, boots, whiskers);
  783. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Hubert"));
  784. e.Current.Pets.AssertThat (Is.SameAs); // empty
  785. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Isidor"));
  786. e.Current.Pets.AssertThat (Is.SameAs, daisy);
  787. Assert.That (e.MoveNext (), Is.False);
  788. }
  789. }
  790. [Test]
  791. public void GroupJoin_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArgComparerArg_ValidArguments_CorrectGroupingAndJoining ()
  792. {
  793. var persons = Read (Person.CreatePersons ());
  794. var barley = new Pet { Name = "Barley", Owner = "Peter" };
  795. var boots = new Pet { Name = "Boots", Owner = "Herbert" };
  796. var whiskers = new Pet { Name = "Whiskers", Owner = "HeRbErT" };
  797. var daisy = new Pet { Name = "Daisy", Owner = "Isidor" };
  798. var pets = Read (barley, boots, whiskers, daisy);
  799. var result = persons.GroupJoin (pets, person => person.FirstName, pet => pet.Owner,
  800. (person, ppets) => new { Owner = person, Pets = ppets },
  801. StringComparer.CurrentCultureIgnoreCase);
  802. using (var e = result.GetEnumerator ()) {
  803. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Peter"));
  804. e.Current.Pets.AssertThat (Is.SameAs, barley);
  805. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Herbert"));
  806. e.Current.Pets.AssertThat (Is.SameAs, boots, whiskers);
  807. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Hubert"));
  808. e.Current.Pets.AssertThat (Is.SameAs); // empty
  809. e.MoveNext (); Assert.That (e.Current.Owner.FirstName, Is.EqualTo ("Isidor"));
  810. e.Current.Pets.AssertThat (Is.SameAs, daisy);
  811. Assert.That (e.MoveNext (), Is.False);
  812. }
  813. }
  814. [Test]
  815. [ExpectedException (typeof (ArgumentNullException))]
  816. public void GroupJoin_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArg_NullOuterKeySelector_ThrowsArgumentNullException ()
  817. {
  818. new object [0].GroupJoin<object, object, object, object> (
  819. new object [0], null,
  820. delegate { throw new NotImplementedException (); },
  821. delegate { throw new NotImplementedException (); });
  822. }
  823. [Test]
  824. [ExpectedException (typeof (ArgumentNullException))]
  825. public void Intersect_NullSecondSource_ThrowsArgumentNullException ()
  826. {
  827. Read<object> ().Intersect (null);
  828. }
  829. [Test]
  830. public void Intersect_IntegerSources_YieldsCommonSet ()
  831. {
  832. var first = Read (1, 2, 3);
  833. var second = Read (2, 3, 4);
  834. first.Intersect (second).AssertEquals (2, 3);
  835. }
  836. [Test]
  837. public void Intersect_MixedStringsAndCaseInsensitiveComparer_YieldsCommonSetFromFirstSource ()
  838. {
  839. var first = Read ("Heinrich", "Hubert", "Thomas");
  840. var second = Read ("Heinrich", "hubert", "Joseph");
  841. var result = first.Intersect (second, StringComparer.CurrentCultureIgnoreCase);
  842. result.AssertEquals ("Heinrich", "Hubert");
  843. }
  844. [Test]
  845. [ExpectedException (typeof (ArgumentNullException))]
  846. public void Join_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArg_PassNullAsArgument_ThrowsArgumentNullException ()
  847. {
  848. Read<object> ().Join<object, object, object, object> (null, null, null, null);
  849. }
  850. [Test]
  851. public void Join_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArg_PassingPetsAndOwners_PetsAreCorrectlyAssignedToOwners ()
  852. {
  853. var persons = Read (Person.CreatePersons ());
  854. var pets = new Reader<Pet> (new []
  855. {
  856. new Pet {Name = "Barley", Owner = "Peter"},
  857. new Pet {Name = "Boots", Owner = "Herbert"},
  858. new Pet {Name = "Whiskers", Owner = "Herbert"},
  859. new Pet {Name = "Daisy", Owner = "Isidor"}
  860. });
  861. var result = persons.Join (pets, aPerson => aPerson.FirstName, aPet => aPet.Owner,
  862. (aPerson, aPet) => new { Owner = aPerson.FirstName, Pet = aPet.Name });
  863. var e = result.GetEnumerator ();
  864. Assert.That (e.MoveNext (), Is.True);
  865. Assert.That (e.Current.Owner, Is.EqualTo ("Peter"));
  866. Assert.That (e.Current.Pet, Is.EqualTo ("Barley"));
  867. Assert.That (e.MoveNext (), Is.True);
  868. Assert.That (e.Current.Owner, Is.EqualTo ("Herbert"));
  869. Assert.That (e.Current.Pet, Is.EqualTo ("Boots"));
  870. Assert.That (e.MoveNext (), Is.True);
  871. Assert.That (e.Current.Owner, Is.EqualTo ("Herbert"));
  872. Assert.That (e.Current.Pet, Is.EqualTo ("Whiskers"));
  873. Assert.That (e.MoveNext (), Is.True);
  874. Assert.That (e.Current.Owner, Is.EqualTo ("Isidor"));
  875. Assert.That (e.Current.Pet, Is.EqualTo ("Daisy"));
  876. Assert.That (e.MoveNext (), Is.False);
  877. }
  878. [Test]
  879. public void Join_InnerArgOuterKeySelectorArgInnerKeySelectorArgResultSelectorArgComparerArg_PetOwnersNamesCasingIsInconsistent_CaseInsensitiveJoinIsPerformed ()
  880. {
  881. var persons = Read (Person.CreatePersons ());
  882. var pets = new Reader<Pet> (new []
  883. {
  884. new Pet {Name = "Barley", Owner = "Peter"},
  885. new Pet {Name = "Boots", Owner = "Herbert"},
  886. new Pet {Name = "Whiskers", Owner = "herbert"},
  887. new Pet {Name = "Daisy", Owner = "Isidor"}
  888. });
  889. var result = persons.Join (pets, aPerson => aPerson.FirstName, aPet => aPet.Owner,
  890. (aPerson, aPet) => new { Owner = aPerson.FirstName, Pet = aPet.Name },
  891. StringComparer.CurrentCultureIgnoreCase);
  892. var e = result.GetEnumerator ();
  893. Assert.That (e.MoveNext (), Is.True);
  894. Assert.That (e.Current.Owner, Is.EqualTo ("Peter"));
  895. Assert.That (e.Current.Pet, Is.EqualTo ("Barley"));
  896. Assert.That (e.MoveNext (), Is.True);
  897. Assert.That (e.Current.Owner, Is.EqualTo ("Herbert"));
  898. Assert.That (e.Current.Pet, Is.EqualTo ("Boots"));
  899. Assert.That (e.MoveNext (), Is.True);
  900. Assert.That (e.Current.Owner, Is.EqualTo ("Herbert"));
  901. Assert.That (e.Current.Pet, Is.EqualTo ("Whiskers"));
  902. Assert.That (e.MoveNext (), Is.True);
  903. Assert.That (e.Current.Owner, Is.EqualTo ("Isidor"));
  904. Assert.That (e.Current.Pet, Is.EqualTo ("Daisy"));
  905. Assert.That (e.MoveNext (), Is.False);
  906. }
  907. [Test]
  908. public void Last_Integers_ReturnsLastElement ()
  909. {
  910. var source = Read (1, 2, 3);
  911. Assert.That (source.Last (), Is.EqualTo (3));
  912. }
  913. [Test]
  914. public void Last_IntegerListOptimization_ReturnsLastElementWithoutEnumerating ()
  915. {
  916. var source = new NonEnumerableList<int> (new [] { 1, 2, 3 });
  917. Assert.That (source.Last (), Is.EqualTo (3));
  918. }
  919. [Test]
  920. [ExpectedException (typeof (InvalidOperationException))]
  921. public void Last_EmptyIntegerListOptimization_ThrowsInvalidOperationException ()
  922. {
  923. new NonEnumerableList<int> ().Last ();
  924. }
  925. [Test]
  926. [ExpectedException (typeof (ArgumentNullException))]
  927. public void Last_PredicateArg_NullAsPredicate_ThrowsArgumentNullException ()
  928. {
  929. Read<object> ().Last (null);
  930. }
  931. [Test]
  932. [ExpectedException (typeof (InvalidOperationException))]
  933. public void Last_PredicateArg_NoMatchingElement_ThrowsInvalidOperationException ()
  934. {
  935. var source = Read (1, 2, 3, 4, 5);
  936. source.Last (i => i > 10);
  937. }
  938. [Test]
  939. public void Last_PredicateArg_ListOfInts_ReturnsLastMatchingElement ()
  940. {
  941. var source = Read (1, 2, 3, 4, 5);
  942. Assert.That (source.Last (i => i % 2 == 0), Is.EqualTo (4));
  943. }
  944. [Test]
  945. public void LastOrDefault_EmptySource_ReturnsZero ()
  946. {
  947. var source = Read (new int [0]);
  948. Assert.That (source.LastOrDefault (), Is.EqualTo (0));
  949. }
  950. [Test]
  951. public void LastOrDefault_NonEmptyList_ReturnsLastElement ()
  952. {
  953. var source = Read (1, 2, 3, 4, 5);
  954. Assert.That (source.LastOrDefault (), Is.EqualTo (5));
  955. }
  956. [Test]
  957. public void LastOrDefault_PredicateArg_ValidArguments_RetunsLastMatchingElement ()
  958. {
  959. var source = Read (1, 2, 3, 4, 5);
  960. Assert.That (source.LastOrDefault (i => i % 2 == 0), Is.EqualTo (4));
  961. }
  962. [Test]
  963. public void LastOrDefault_PredicateArg_NoMatchingElement_ReturnsZero ()
  964. {
  965. var source = Read (1, 3, 5, 7);
  966. Assert.That (source.LastOrDefault (i => i % 2 == 0), Is.EqualTo (0));
  967. }
  968. [Test]
  969. public void LongCount_ValidArgument_ReturnsCorrectNumberOfElements ()
  970. {
  971. var source = Read (1, 4, 7, 10);
  972. Assert.That (source.LongCount (), Is.EqualTo (4));
  973. }
  974. [Test]
  975. [ExpectedException (typeof (ArgumentNullException))]
  976. public void LongCount_PredicateArg_NullAsPredicate_ThrowsArgumentNullException ()
  977. {
  978. Read<object> ().LongCount (null);
  979. }
  980. [Test]
  981. public void LongCount_PredicateArg_ValidArguments_ReturnsCorrectNumerOfMatchingElements ()
  982. {
  983. var source = Read (1, 2, 3, 4, 5);
  984. Assert.That (source.LongCount (i => i % 2 == 0), Is.EqualTo (2));
  985. }
  986. [Test]
  987. [ExpectedException (typeof (InvalidOperationException))]
  988. public void Max_EmptyList_ThrowsInvalidOperationException ()
  989. {
  990. var source = Read (new int [0]);
  991. source.Max ();
  992. }
  993. [Test]
  994. public void Max_EmptyNullableIntegerArray_ReturnsNull ()
  995. {
  996. Assert.That (Read (new int? [0]).Max (), Is.Null);
  997. }
  998. [Test]
  999. public void Max_NullableIntegerArrayWithNullsOnly_ReturnsNull ()
  1000. {
  1001. Assert.That (Read<int?> (null, null, null).Max (), Is.Null);
  1002. }
  1003. [Test]
  1004. public void Max_Integers_ReturnsMaxValue ()
  1005. {
  1006. var source = Read (1000, 203, -9999);
  1007. Assert.That (source.Max (), Is.EqualTo (1000));
  1008. }
  1009. [Test]
  1010. public void Max_NullableLongs_ReturnsMaxValue ()
  1011. {
  1012. Assert.That (Read<long?> (1L, 2L, 3L, null).Max (), Is.EqualTo (3));
  1013. }
  1014. [Test]
  1015. public void Max_NullableDoubles_ReturnsMaxValue ()
  1016. {
  1017. Assert.That (Read<double?> (1.0, 2.0, 3.0, null).Max (), Is.EqualTo (3));
  1018. }
  1019. [Test]
  1020. public void Max_NullableDecimals_ReturnsMaxValue ()
  1021. {
  1022. Assert.That (Read<decimal?> (1m, 2m, 3m, null).Max (), Is.EqualTo (3));
  1023. }
  1024. [Test]
  1025. public void Max_NullableFloats_ReturnsMaxValue ()
  1026. {
  1027. Assert.That (Read<float?> (-1000F, -100F, -1F, null).Max (), Is.EqualTo (-1));
  1028. }
  1029. [Test]
  1030. public void Max_ListWithNullableType_ReturnsMaximum ()
  1031. {
  1032. var source = Read<int?> (1, 4, null, 10);
  1033. Assert.That (source.Max (), Is.EqualTo (10));
  1034. }
  1035. [Test]
  1036. public void Max_NullableList_ReturnsMaxNonNullValue ()
  1037. {
  1038. var source = Read<int?> (-5, -2, null);
  1039. Assert.That (source.Max (), Is.EqualTo (-2));
  1040. }
  1041. [Test]
  1042. public void Max_SelectorArg_ListOfObjects_ReturnsMaxSelectedValue ()
  1043. {
  1044. var persons = Read (Person.CreatePersons ());
  1045. Assert.That (persons.Max (p => p.Age), Is.EqualTo (24));
  1046. }
  1047. [Test]
  1048. [ExpectedException (typeof (InvalidOperationException))]
  1049. public void Min_EmptyList_ThrowsInvalidOperationException ()
  1050. {
  1051. var source = Read<int> ();
  1052. source.Min ();
  1053. }
  1054. [Test]
  1055. public void Min_IntegersWithSomeNull_ReturnsMinimumNonNullValue ()
  1056. {
  1057. var source = Read<int?> (199, 15, null, 30);
  1058. Assert.That (source.Min (), Is.EqualTo (15));
  1059. }
  1060. [Test]
  1061. public void Min_NullableLongs_ReturnsMinimumNonNullValue ()
  1062. {
  1063. var source = Read<long?> (199L, 15L, null, 30L);
  1064. Assert.That (source.Min (), Is.EqualTo (15));
  1065. }
  1066. [Test]
  1067. public void Min_NullableFloats_ReturnsMinimumNonNullValue ()
  1068. {
  1069. var source = Read<float?> (1.111F, null, 2.222F); // TODO Improve test data
  1070. Assert.That (source.Min (), Is.EqualTo (1.111F).Within (0.01));
  1071. }
  1072. [Test]
  1073. public void Min_NullableDoubles_ReturnsMinimumNonNullValue ()
  1074. {
  1075. var source = Read<double?> (1.111, null, 2.222); // TODO Improve test data
  1076. Assert.That (source.Min (), Is.EqualTo (1.111).Within (0.01));
  1077. }
  1078. [Test]
  1079. public void Min_NullableDecimals_ReturnsMinimumNonNullValue ()
  1080. {
  1081. var source = Read<decimal?> (1.111m, null, 2.222m); // TODO Improve test data
  1082. Assert.That (source.Min (), Is.EqualTo (1.111m).Within (0.01));
  1083. }
  1084. [Test]
  1085. public void Min_Chars_ReturnsMinimumBySortOrder ()
  1086. {
  1087. Assert.That ("qwertzuioplkjhgfdsayxcvbnm".ToCharArray ().Min (), Is.EqualTo ('a'));
  1088. }
  1089. [Test]
  1090. public void Min_StringsWithLengthSelector_ReturnsMinimumNonNullStringLength ()
  1091. {
  1092. var strings = Read ("five", "four", null, "three", null, "two", "one", "zero");
  1093. Assert.That (strings.Min (s => s != null ? s.Length : (int?) null), Is.EqualTo (3));
  1094. }
  1095. [Test]
  1096. public void OfType_EnumerableWithElementsOfDifferentTypes_OnlyDecimalsAreReturned ()
  1097. {
  1098. var source = Read<object> (1, "Hello", 1.234m, new object ());
  1099. var result = source.OfType<decimal> ();
  1100. result.AssertEquals (1.234m);
  1101. }
  1102. [Test]
  1103. [ExpectedException (typeof (ArgumentNullException))]
  1104. public void OrderBy_KeySelectorArg_NullAsKeySelector_ThrowsArgumentNullException ()
  1105. {
  1106. Read<object> ().OrderBy<object, object> (null);
  1107. }
  1108. [Test]
  1109. public void OrderBy_KeySelector_ArrayOfPersons_PersonsAreOrderedByAge ()
  1110. {
  1111. var persons = Person.CreatePersons ();
  1112. var reversePersons = (Person []) persons.Clone ();
  1113. Array.Reverse (reversePersons);
  1114. var source = Read (reversePersons);
  1115. var result = source.OrderBy (p => p.Age);
  1116. var age = 21;
  1117. foreach (var person in result)
  1118. Assert.That (person.Age, Is.EqualTo (age++));
  1119. Assert.That (age, Is.EqualTo (25));
  1120. }
  1121. [Test]
  1122. public void OrderBy_KeySelector_DataWithDuplicateKeys_YieldsStablySortedData ()
  1123. {
  1124. var data = new []
  1125. {
  1126. new { Number = 4, Text = "four" },
  1127. new { Number = 4, Text = "quatre" },
  1128. new { Number = 4, Text = "vier" },
  1129. new { Number = 4, Text = "quattro" },
  1130. new { Number = 1, Text = "one" },
  1131. new { Number = 2, Text = "two" },
  1132. new { Number = 2, Text = "deux" },
  1133. new { Number = 3, Text = "three" },
  1134. new { Number = 3, Text = "trois" },
  1135. new { Number = 3, Text = "drei" },
  1136. };
  1137. var result = Read (data).OrderBy (e => e.Number);
  1138. using (var e = result.GetEnumerator ()) {
  1139. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("one"));
  1140. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("two"));
  1141. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("deux"));
  1142. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("three"));
  1143. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("trois"));
  1144. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("drei"));
  1145. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("four"));
  1146. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("quatre"));
  1147. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("vier"));
  1148. e.MoveNext (); Assert.That (e.Current.Text, Is.EqualTo ("quattro"));
  1149. Assert.That (e.MoveNext (), Is.False);
  1150. }
  1151. }
  1152. [Test]
  1153. public void ThenBy_KeySelector_DataWithDuplicateKeys_YieldsStablySortedData ()
  1154. {
  1155. var data = new []
  1156. {
  1157. new { Position = 1, LastName = "Smith", FirstName = "John" },
  1158. new { Position = 2, LastName = "Smith", FirstName = "Jack" },
  1159. new { Position = 3, LastName = "Smith", FirstName = "John" },
  1160. new { Position = 4, LastName = "Smith", FirstName = "Jack" },
  1161. new { Position = 5, LastName = "Smith", FirstName = "John" },
  1162. new { Position = 6, LastName = "Smith", FirstName = "Jack" },
  1163. };
  1164. var result = Read (data).OrderBy (e => e.LastName).ThenBy (e => e.FirstName);
  1165. using (var e = result.GetEnumerator ()) {
  1166. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (2));
  1167. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (4));
  1168. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (6));
  1169. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (1));
  1170. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (3));
  1171. e.MoveNext (); Assert.That (e.Current.Position, Is.EqualTo (5));
  1172. Assert.That (e.MoveNext (), Is.False);
  1173. }
  1174. }
  1175. [Test]
  1176. [ExpectedException (typeof (ArgumentNullException))]
  1177. public void ThenBy_NullSource_ThrowsArgumentNullException ()
  1178. {
  1179. Enumerable.ThenBy<object, object> (null, delegate { throw new NotImplementedException (); });
  1180. }
  1181. [Test]
  1182. [ExpectedException (typeof (ArgumentNullException))]
  1183. public void ThenBy_NullKeySelector_ThrowsArgumentNullException ()
  1184. {
  1185. Read<object> ().OrderBy<object, object> (e => { throw new NotImplementedException (); }).ThenBy<object, object> (null);
  1186. }
  1187. [Test]
  1188. public void ThenByDescending_KeySelectorArgComparerArg_StringArray_CorrectOrdering ()
  1189. {
  1190. var source = Read ("AA", "AB", "AC", "-BA", "-BB", "-BC");
  1191. var result = source.OrderBy (s => s.ToCharArray () [s.ToCharArray ().Length - 1]).ThenByDescending (s => s.Length); /*.AssertEquals("butterfly", "elephant", "dog", "snake", "ape"); */
  1192. result.AssertEquals ("-BA", "AA", "-BB", "AB", "-BC", "AC");
  1193. }
  1194. class ReverseComparer<T> : IComparer<T> where T : IComparable<T> {
  1195. public int Compare (T x, T y)
  1196. {
  1197. return -1 * x.CompareTo (y);
  1198. }
  1199. }
  1200. [Test]
  1201. public void OrderBy_KeySelectorArgComparerArg_ArrayOfPersonsAndReversecomparer_PersonsAreOrderedByAgeUsingReversecomparer ()
  1202. {
  1203. var persons = Read (Person.CreatePersons ());
  1204. var result = persons.OrderBy (p => p.Age, new ReverseComparer<int> ());
  1205. var age = 25;
  1206. foreach (var person in result) {
  1207. age--;
  1208. Assert.That (person.Age, Is.EqualTo (age));
  1209. }
  1210. Assert.That (age, Is.EqualTo (21));
  1211. }
  1212. [Test]
  1213. public void OrderByDescending_KeySelectorArg_ArrayOfPersons_PersonsAreOrderedByAgeDescending ()
  1214. {
  1215. var persons = Read (Person.CreatePersons ());
  1216. var result = persons.OrderByDescending (p => p.Age);
  1217. int age = 25;
  1218. foreach (var person in result) {
  1219. age--;
  1220. Assert.That (person.Age, Is.EqualTo (age));
  1221. }
  1222. Assert.That (age, Is.EqualTo (21));
  1223. }
  1224. [Test]
  1225. [ExpectedException (typeof (ArgumentOutOfRangeException))]
  1226. public void Range_ProduceRangeThatLeadsToOverflow_ThrowsArgumentOutOfRangeException ()
  1227. {
  1228. Enumerable.Range (int.MaxValue - 3, 5);
  1229. }
  1230. [Test]
  1231. [ExpectedException (typeof (ArgumentOutOfRangeException))]
  1232. public void Range_NegativeCount_ThrowsArgumentOutOfRangeException ()
  1233. {
  1234. Enumerable.Range (0, -1);
  1235. }
  1236. [Test]
  1237. public void Range_Start10Count5_IntsFrom10To14 ()
  1238. {
  1239. var result = Enumerable.Range (10, 5);
  1240. result.AssertEquals (10, 11, 12, 13, 14);
  1241. }
  1242. [Test]
  1243. [ExpectedException (typeof (ArgumentOutOfRangeException))]
  1244. public void Repeat_PassNegativeCount_ThrowsArgumentOutOfRangeException ()
  1245. {
  1246. Enumerable.Repeat ("Hello World", -2);
  1247. }
  1248. [Test]
  1249. public void Repeat_StringArgumentCount2_ReturnValueContainsStringArgumentTwice ()
  1250. {
  1251. var result = Enumerable.Repeat ("Hello World", 2);
  1252. result.AssertEquals ("Hello World", "Hello World");
  1253. }
  1254. [Test]
  1255. public void Reverse_SeriesOfInts_IntsAreCorrectlyReversed ()
  1256. {
  1257. var source = Read (1, 2, 3, 4, 5);
  1258. source.Reverse ().AssertEquals (5, 4, 3, 2, 1);
  1259. }
  1260. [Test]
  1261. public void Select_ArrayOfPersons_AgeOfPersonsIsSelectedAccordingToPassedLambdaExpression ()
  1262. {
  1263. var persons = Read (Person.CreatePersons ());
  1264. persons.Select (p => p.Age).AssertEquals (21, 22, 23, 24);
  1265. }
  1266. [Test]
  1267. public void Select_SelectorArg_LambdaThatTakesIndexAsArgument_ReturnValueContainsElementsMultipliedByIndex ()
  1268. {
  1269. var source = Read (0, 1, 2, 3);
  1270. source.Select ((i, index) => i * index).AssertEquals (0, 1, 4, 9);
  1271. }
  1272. [Test]
  1273. public void SelectMany_SelectorArg_ArrayOfPersons_ReturnsASequenceWithAllLettersOfFirstnames ()
  1274. {
  1275. var persons = Read (Person.CreatePersons ());
  1276. var result = persons.SelectMany (p => p.FirstName.ToCharArray ());
  1277. var check = "PeterHerbertHubertIsidor".ToCharArray ();
  1278. int count = 0; // BUGBUG Collapse loop-based check with array assertion!
  1279. foreach (var c in result) {
  1280. Assert.That (c, Is.EqualTo (check [count]));
  1281. count++;
  1282. }
  1283. }
  1284. class PetOwner {
  1285. public string Name { get; set; }
  1286. public IList<string> Pets { get; set; }
  1287. }
  1288. [Test]
  1289. public void SelectMany_Selector3Arg_ArrayOfPetOwners_SelectorUsesElementIndexArgument ()
  1290. {
  1291. var petOwners = Read (new [] {
  1292. new PetOwner { Name = "Higa, Sidney", Pets = new[] { "Scruffy", "Sam" } },
  1293. new PetOwner { Name = "Ashkenazi, Ronen", Pets = new[] { "Walker", "Sugar" } },
  1294. new PetOwner { Name = "Price, Vernette", Pets = new[] { "Scratches", "Diesel" } },
  1295. new PetOwner { Name = "Hines, Patrick", Pets = new[] { "Dusty" } } });
  1296. var result = petOwners.SelectMany ((po, index) => po.Pets.Select (pet => index + pet));
  1297. result.AssertEquals ("0Scruffy", "0Sam", "1Walker", "1Sugar", "2Scratches", "2Diesel", "3Dusty");
  1298. }
  1299. [Test]
  1300. public void SelectMany_CollectionSelectorArgResultSelectorArg_ArrayOfPetOwner_ResultContainsElementForEachPetAPetOwnerHas ()
  1301. {
  1302. var petOwners = Read (new [] {
  1303. new PetOwner { Name = "Higa", Pets = new[] { "Scruffy", "Sam" } },
  1304. new PetOwner { Name = "Ashkenazi", Pets = new[] { "Walker", "Sugar" } },
  1305. new PetOwner { Name = "Price", Pets = new[] { "Scratches", "Diesel" } },
  1306. new PetOwner { Name = "Hines", Pets = new[] { "Dusty" } } });
  1307. var result = petOwners.SelectMany (po => po.Pets, (po, pet) => po.Name + "+" + pet);
  1308. result.AssertEquals (
  1309. "Higa+Scruffy", "Higa+Sam",
  1310. "Ashkenazi+Walker", "Ashkenazi+Sugar",
  1311. "Price+Scratches", "Price+Diesel",
  1312. "Hines+Dusty");
  1313. }
  1314. [Test]
  1315. [ExpectedException (typeof (ArgumentNullException))]
  1316. public void SequenceEqual_NullFirstSequence_ThrowsArgumentNullException ()
  1317. {
  1318. Enumerable.SequenceEqual (null, Read<object> ());
  1319. }
  1320. [Test]
  1321. [ExpectedException (typeof (ArgumentNullException))]
  1322. public void SequenceEqual_NullSecondSequence_ThrowsArgumentNullException ()
  1323. {
  1324. Read<object> ().SequenceEqual (null);
  1325. }
  1326. [Test]
  1327. public void SequenceEqual_EqualSequences_ReturnsTrue ()
  1328. {
  1329. var source = Read (1, 2, 3);
  1330. var argument = Read (1, 2, 3);
  1331. Assert.That (source.SequenceEqual (argument), Is.True);
  1332. }
  1333. [Test]
  1334. public void SequenceEqual_DifferentSequences_ReturnsFalse ()
  1335. {
  1336. var source = Read (1, 2, 3);
  1337. var argument = Read (1, 3, 2);
  1338. Assert.That (source.SequenceEqual (argument), Is.False);
  1339. }
  1340. [Test]
  1341. public void SequenceEqual_LongerSecondSequence_ReturnsFalse ()
  1342. {
  1343. var source = Read (1, 2, 3);
  1344. var argument = Read (1, 2, 3

Large files files are truncated, but you can click here to view the full file