MemoizeTest.cs 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273
  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.Text;
  7. using System.Linq;
  8. using Xunit;
  9. using System.Collections;
  10. namespace Tests
  11. {
  12. public class MemoizeTest : Tests
  13. {
  14. [Fact]
  15. public void Memoize_Arguments()
  16. {
  17. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int>(null));
  18. }
  19. [Fact]
  20. public void MemoizeLimited_Arguments()
  21. {
  22. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int>(null, 2));
  23. AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int>(new[] { 1 }, 0));
  24. AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int>(new[] { 1 }, -1));
  25. }
  26. [Fact]
  27. public void Memoize0()
  28. {
  29. var n = 0;
  30. var rng = Tick(i => n += i).Memoize();
  31. var e1 = rng.GetEnumerator();
  32. var e2 = rng.GetEnumerator();
  33. HasNext(e1, 0);
  34. Assert.Equal(0, n);
  35. HasNext(e1, 1);
  36. Assert.Equal(1, n);
  37. HasNext(e1, 2);
  38. Assert.Equal(3, n);
  39. HasNext(e2, 0);
  40. Assert.Equal(3, n);
  41. HasNext(e1, 3);
  42. Assert.Equal(6, n);
  43. HasNext(e2, 1);
  44. Assert.Equal(6, n);
  45. HasNext(e2, 2);
  46. Assert.Equal(6, n);
  47. HasNext(e2, 3);
  48. Assert.Equal(6, n);
  49. HasNext(e2, 4);
  50. Assert.Equal(10, n);
  51. HasNext(e1, 4);
  52. Assert.Equal(10, n);
  53. }
  54. [Fact]
  55. public void Memoize1()
  56. {
  57. var rng = Enumerable.Range(0, 5).Memoize();
  58. var e1 = rng.GetEnumerator();
  59. HasNext(e1, 0);
  60. HasNext(e1, 1);
  61. HasNext(e1, 2);
  62. HasNext(e1, 3);
  63. HasNext(e1, 4);
  64. NoNext(e1);
  65. }
  66. [Fact]
  67. public void Memoize2()
  68. {
  69. var rng = Enumerable.Range(0, 5).Memoize();
  70. var e1 = rng.GetEnumerator();
  71. HasNext(e1, 0);
  72. HasNext(e1, 1);
  73. HasNext(e1, 2);
  74. HasNext(e1, 3);
  75. HasNext(e1, 4);
  76. NoNext(e1);
  77. var e2 = rng.GetEnumerator();
  78. HasNext(e2, 0);
  79. HasNext(e2, 1);
  80. HasNext(e2, 2);
  81. HasNext(e2, 3);
  82. HasNext(e2, 4);
  83. NoNext(e2);
  84. }
  85. [Fact]
  86. public void Memoize3()
  87. {
  88. var rng = Enumerable.Range(0, 5).Memoize();
  89. var e1 = rng.GetEnumerator();
  90. HasNext(e1, 0);
  91. HasNext(e1, 1);
  92. HasNext(e1, 2);
  93. var e2 = rng.GetEnumerator();
  94. HasNext(e1, 3);
  95. HasNext(e2, 0);
  96. HasNext(e2, 1);
  97. HasNext(e1, 4);
  98. HasNext(e2, 2);
  99. NoNext(e1);
  100. HasNext(e2, 3);
  101. HasNext(e2, 4);
  102. NoNext(e2);
  103. }
  104. [Fact]
  105. public void Memoize4()
  106. {
  107. var rng = Enumerable.Range(0, 5).Memoize(2);
  108. var e1 = rng.GetEnumerator();
  109. HasNext(e1, 0);
  110. HasNext(e1, 1);
  111. HasNext(e1, 2);
  112. var e2 = rng.GetEnumerator();
  113. HasNext(e2, 0);
  114. HasNext(e2, 1);
  115. HasNext(e2, 2);
  116. var e3 = rng.GetEnumerator();
  117. AssertThrows<InvalidOperationException>(() => e3.MoveNext());
  118. }
  119. [Fact]
  120. public void Memoize6()
  121. {
  122. var ex = new MyException();
  123. var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex)).Memoize();
  124. var e1 = rng.GetEnumerator();
  125. var e2 = rng.GetEnumerator();
  126. HasNext(e1, 0);
  127. HasNext(e1, 1);
  128. AssertThrows<MyException>(() => e1.MoveNext());
  129. HasNext(e2, 0);
  130. HasNext(e2, 1);
  131. AssertThrows<MyException>(() => e2.MoveNext());
  132. }
  133. [Fact]
  134. public void Memoize7()
  135. {
  136. var rng = Enumerable.Range(0, 5).Memoize();
  137. var e1 = rng.GetEnumerator();
  138. HasNext(e1, 0);
  139. HasNext(e1, 1);
  140. HasNext(e1, 2);
  141. e1.Dispose();
  142. var e2 = rng.GetEnumerator();
  143. HasNext(e2, 0);
  144. HasNext(e2, 1);
  145. e2.Dispose();
  146. var e3 = rng.GetEnumerator();
  147. HasNext(e3, 0);
  148. HasNext(e3, 1);
  149. HasNext(e3, 2);
  150. HasNext(e3, 3);
  151. HasNext(e3, 4);
  152. NoNext(e3);
  153. }
  154. [Fact]
  155. public void Memoize8()
  156. {
  157. var rng = Enumerable.Range(0, 5).Memoize();
  158. var e1 = rng.GetEnumerator();
  159. HasNext(e1, 0);
  160. HasNext(e1, 1);
  161. HasNext(e1, 2);
  162. rng.Dispose();
  163. AssertThrows<ObjectDisposedException>(() => e1.MoveNext());
  164. AssertThrows<ObjectDisposedException>(() => rng.GetEnumerator());
  165. AssertThrows<ObjectDisposedException>(() => ((IEnumerable)rng).GetEnumerator());
  166. }
  167. [Fact]
  168. public void Memoize9()
  169. {
  170. var rng = Enumerable.Range(0, 5).Memoize();
  171. var e1 = ((IEnumerable)rng).GetEnumerator();
  172. Assert.True(e1.MoveNext());
  173. Assert.Equal(0, (int)e1.Current);
  174. }
  175. [Fact]
  176. public void Memoize10()
  177. {
  178. var rnd = Rand().Take(1000).Memoize();
  179. Assert.True(rnd.Zip(rnd, (l, r) => l == r).All(x => x));
  180. }
  181. [Fact]
  182. public void MemoizeLambda_Arguments()
  183. {
  184. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(null, xs => xs));
  185. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, null));
  186. }
  187. [Fact]
  188. public void MemoizeLambda()
  189. {
  190. var n = 0;
  191. var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
  192. Assert.True(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
  193. Assert.Equal(4, n);
  194. }
  195. [Fact]
  196. public void MemoizeLimitedLambda_Arguments()
  197. {
  198. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(null, 2, xs => xs));
  199. AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, 2, null));
  200. AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, 0, xs => xs));
  201. AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, -1, xs => xs));
  202. }
  203. [Fact]
  204. public void MemoizeLimitedLambda()
  205. {
  206. var n = 0;
  207. var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(2, xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
  208. Assert.True(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
  209. Assert.Equal(4, n);
  210. }
  211. private static readonly Random Random = new Random();
  212. private static IEnumerable<int> Rand()
  213. {
  214. while (true)
  215. {
  216. yield return Random.Next();
  217. }
  218. }
  219. private static IEnumerable<int> Tick(Action<int> t)
  220. {
  221. var i = 0;
  222. while (true)
  223. {
  224. t(i);
  225. yield return i++;
  226. }
  227. }
  228. }
  229. }