UsingTest.cs 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  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.Reactive.Linq;
  6. using Microsoft.Reactive.Testing;
  7. using ReactiveTests.Dummies;
  8. using Xunit;
  9. namespace ReactiveTests.Tests
  10. {
  11. public class UsingTest : ReactiveTest
  12. {
  13. [Fact]
  14. public void Using_ArgumentChecking()
  15. {
  16. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Using(null, DummyFunc<IDisposable, IObservable<int>>.Instance));
  17. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Using(DummyFunc<IDisposable>.Instance, (Func<IDisposable, IObservable<int>>)null));
  18. ReactiveAssert.Throws</*some*/Exception>(() => Observable.Using(() => DummyDisposable.Instance, d => default(IObservable<int>)).Subscribe());
  19. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Using(() => DummyDisposable.Instance, d => DummyObservable<int>.Instance).Subscribe(null));
  20. }
  21. [Fact]
  22. public void Using_Null()
  23. {
  24. var scheduler = new TestScheduler();
  25. var disposeInvoked = 0L;
  26. var createInvoked = 0L;
  27. var xs = default(ITestableObservable<long>);
  28. var disposable = default(MockDisposable);
  29. var _d = default(MockDisposable);
  30. var res = scheduler.Start(() =>
  31. Observable.Using(
  32. () =>
  33. {
  34. disposeInvoked++;
  35. disposable = default;
  36. return disposable;
  37. },
  38. d =>
  39. {
  40. _d = d;
  41. createInvoked++;
  42. xs = scheduler.CreateColdObservable(
  43. OnNext(100, scheduler.Clock),
  44. OnCompleted<long>(200));
  45. return xs;
  46. }
  47. )
  48. );
  49. Assert.Same(disposable, _d);
  50. res.Messages.AssertEqual(
  51. OnNext(300, 200L),
  52. OnCompleted<long>(400)
  53. );
  54. Assert.Equal(1, createInvoked);
  55. Assert.Equal(1, disposeInvoked);
  56. xs.Subscriptions.AssertEqual(
  57. Subscribe(200, 400)
  58. );
  59. Assert.Null(disposable);
  60. }
  61. [Fact]
  62. public void Using_Complete()
  63. {
  64. var scheduler = new TestScheduler();
  65. var disposeInvoked = 0;
  66. var createInvoked = 0;
  67. var xs = default(ITestableObservable<long>);
  68. var disposable = default(MockDisposable);
  69. var _d = default(MockDisposable);
  70. var res = scheduler.Start(() =>
  71. Observable.Using(
  72. () =>
  73. {
  74. disposeInvoked++;
  75. disposable = new MockDisposable(scheduler);
  76. return disposable;
  77. },
  78. d =>
  79. {
  80. _d = d;
  81. createInvoked++;
  82. xs = scheduler.CreateColdObservable(
  83. OnNext(100, scheduler.Clock),
  84. OnCompleted<long>(200));
  85. return xs;
  86. }
  87. )
  88. );
  89. Assert.Same(disposable, _d);
  90. res.Messages.AssertEqual(
  91. OnNext(300, 200L),
  92. OnCompleted<long>(400)
  93. );
  94. Assert.Equal(1, createInvoked);
  95. Assert.Equal(1, disposeInvoked);
  96. xs.Subscriptions.AssertEqual(
  97. Subscribe(200, 400)
  98. );
  99. disposable.AssertEqual(
  100. 200,
  101. 400
  102. );
  103. }
  104. [Fact]
  105. public void Using_Error()
  106. {
  107. var scheduler = new TestScheduler();
  108. var disposeInvoked = 0;
  109. var createInvoked = 0;
  110. var xs = default(ITestableObservable<long>);
  111. var disposable = default(MockDisposable);
  112. var _d = default(MockDisposable);
  113. var ex = new Exception();
  114. var res = scheduler.Start(() =>
  115. Observable.Using(
  116. () =>
  117. {
  118. disposeInvoked++;
  119. disposable = new MockDisposable(scheduler);
  120. return disposable;
  121. },
  122. d =>
  123. {
  124. _d = d;
  125. createInvoked++;
  126. xs = scheduler.CreateColdObservable(
  127. OnNext(100, scheduler.Clock),
  128. OnError<long>(200, ex));
  129. return xs;
  130. }
  131. )
  132. );
  133. Assert.Same(disposable, _d);
  134. res.Messages.AssertEqual(
  135. OnNext(300, 200L),
  136. OnError<long>(400, ex)
  137. );
  138. Assert.Equal(1, createInvoked);
  139. Assert.Equal(1, disposeInvoked);
  140. xs.Subscriptions.AssertEqual(
  141. Subscribe(200, 400)
  142. );
  143. disposable.AssertEqual(
  144. 200,
  145. 400
  146. );
  147. }
  148. [Fact]
  149. public void Using_Dispose()
  150. {
  151. var scheduler = new TestScheduler();
  152. var disposeInvoked = 0;
  153. var createInvoked = 0;
  154. var xs = default(ITestableObservable<long>);
  155. var disposable = default(MockDisposable);
  156. var _d = default(MockDisposable);
  157. var res = scheduler.Start(() =>
  158. Observable.Using(
  159. () =>
  160. {
  161. disposeInvoked++;
  162. disposable = new MockDisposable(scheduler);
  163. return disposable;
  164. },
  165. d =>
  166. {
  167. _d = d;
  168. createInvoked++;
  169. xs = scheduler.CreateColdObservable(
  170. OnNext(100, scheduler.Clock),
  171. OnNext(1000, scheduler.Clock + 1));
  172. return xs;
  173. }
  174. )
  175. );
  176. Assert.Same(disposable, _d);
  177. res.Messages.AssertEqual(
  178. OnNext(300, 200L)
  179. );
  180. Assert.Equal(1, createInvoked);
  181. Assert.Equal(1, disposeInvoked);
  182. xs.Subscriptions.AssertEqual(
  183. Subscribe(200, 1000)
  184. );
  185. disposable.AssertEqual(
  186. 200,
  187. 1000
  188. );
  189. }
  190. [Fact]
  191. public void Using_ThrowResourceSelector()
  192. {
  193. var scheduler = new TestScheduler();
  194. var disposeInvoked = 0;
  195. var createInvoked = 0;
  196. var ex = new Exception();
  197. var res = scheduler.Start(() =>
  198. Observable.Using<int, IDisposable>(
  199. () =>
  200. {
  201. disposeInvoked++;
  202. throw ex;
  203. },
  204. d =>
  205. {
  206. createInvoked++;
  207. return Observable.Never<int>();
  208. }
  209. )
  210. );
  211. res.Messages.AssertEqual(
  212. OnError<int>(200, ex)
  213. );
  214. Assert.Equal(0, createInvoked);
  215. Assert.Equal(1, disposeInvoked);
  216. }
  217. [Fact]
  218. public void Using_ThrowResourceUsage()
  219. {
  220. var scheduler = new TestScheduler();
  221. var ex = new Exception();
  222. var disposeInvoked = 0;
  223. var createInvoked = 0;
  224. var disposable = default(MockDisposable);
  225. var res = scheduler.Start(() =>
  226. Observable.Using<int, IDisposable>(
  227. () =>
  228. {
  229. disposeInvoked++;
  230. disposable = new MockDisposable(scheduler);
  231. return disposable;
  232. },
  233. d =>
  234. {
  235. createInvoked++;
  236. throw ex;
  237. }
  238. )
  239. );
  240. res.Messages.AssertEqual(
  241. OnError<int>(200, ex)
  242. );
  243. Assert.Equal(1, createInvoked);
  244. Assert.Equal(1, disposeInvoked);
  245. disposable.AssertEqual(
  246. 200,
  247. 200
  248. );
  249. }
  250. }
  251. }