1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 package org.apache.hc.core5.concurrent;
28
29 import java.util.concurrent.CancellationException;
30 import java.util.concurrent.ExecutionException;
31 import java.util.concurrent.TimeUnit;
32 import java.util.concurrent.TimeoutException;
33
34 import org.apache.hc.core5.util.TimeoutValueException;
35 import org.junit.jupiter.api.Assertions;
36 import org.junit.jupiter.api.Test;
37 import org.mockito.Mockito;
38
39 public class TestBasicFuture {
40
41 @Test
42 public void testCompleted() throws Exception {
43 final FutureCallback<Object> callback = Mockito.mock(FutureCallback.class);
44 final BasicFuture<Object> future = new BasicFuture<>(callback);
45
46 Assertions.assertFalse(future.isDone());
47
48 final Object result = new Object();
49 final Exception boom = new Exception();
50 future.completed(result);
51 future.failed(boom);
52 Mockito.verify(callback).completed(result);
53 Mockito.verify(callback, Mockito.never()).failed(Mockito.any());
54 Mockito.verify(callback, Mockito.never()).cancelled();
55
56 Assertions.assertSame(result, future.get());
57 Assertions.assertTrue(future.isDone());
58 Assertions.assertFalse(future.isCancelled());
59
60 }
61
62 @Test
63 public void testCompletedWithTimeout() throws Exception {
64 final FutureCallback<Object> callback = Mockito.mock(FutureCallback.class);
65 final BasicFuture<Object> future = new BasicFuture<>(callback);
66
67 Assertions.assertFalse(future.isDone());
68
69 final Object result = new Object();
70 final Exception boom = new Exception();
71 future.completed(result);
72 future.failed(boom);
73 Mockito.verify(callback).completed(result);
74 Mockito.verify(callback, Mockito.never()).failed(Mockito.any());
75 Mockito.verify(callback, Mockito.never()).cancelled();
76
77 Assertions.assertSame(result, future.get(1, TimeUnit.MILLISECONDS));
78 Assertions.assertTrue(future.isDone());
79 Assertions.assertFalse(future.isCancelled());
80 }
81
82 @Test
83 public void testFailed() throws Exception {
84 final FutureCallback<Object> callback = Mockito.mock(FutureCallback.class);
85 final BasicFuture<Object> future = new BasicFuture<>(callback);
86 final Object result = new Object();
87 final Exception boom = new Exception();
88 future.failed(boom);
89 future.completed(result);
90 Mockito.verify(callback, Mockito.never()).completed(Mockito.any());
91 Mockito.verify(callback).failed(boom);
92 Mockito.verify(callback, Mockito.never()).cancelled();
93
94 try {
95 future.get();
96 } catch (final ExecutionException ex) {
97 Assertions.assertSame(boom, ex.getCause());
98 }
99 Assertions.assertTrue(future.isDone());
100 Assertions.assertFalse(future.isCancelled());
101 }
102
103 @Test
104 public void testCancelled() throws Exception {
105 final FutureCallback<Object> callback = Mockito.mock(FutureCallback.class);
106 final BasicFuture<Object> future = new BasicFuture<>(callback);
107 final Object result = new Object();
108 final Exception boom = new Exception();
109 future.cancel(true);
110 future.failed(boom);
111 future.completed(result);
112 Mockito.verify(callback, Mockito.never()).completed(Mockito.any());
113 Mockito.verify(callback, Mockito.never()).failed(Mockito.any());
114 Mockito.verify(callback).cancelled();
115
116 Assertions.assertThrows(CancellationException.class, future::get);
117 Assertions.assertTrue(future.isDone());
118 Assertions.assertTrue(future.isCancelled());
119 }
120
121 @Test
122 public void testAsyncCompleted() throws Exception {
123 final BasicFuture<Object> future = new BasicFuture<>(null);
124 final Object result = new Object();
125
126 final Thread t = new Thread(() -> {
127 try {
128 Thread.sleep(100);
129 future.completed(result);
130 } catch (final InterruptedException boom) {
131 }
132 });
133 t.setDaemon(true);
134 t.start();
135 Assertions.assertSame(result, future.get(60, TimeUnit.SECONDS));
136 Assertions.assertTrue(future.isDone());
137 Assertions.assertFalse(future.isCancelled());
138 }
139
140 @Test
141 public void testAsyncFailed() throws Exception {
142 final BasicFuture<Object> future = new BasicFuture<>(null);
143 final Exception boom = new Exception();
144
145 final Thread t = new Thread(() -> {
146 try {
147 Thread.sleep(100);
148 future.failed(boom);
149 } catch (final InterruptedException ex) {
150 }
151 });
152 t.setDaemon(true);
153 t.start();
154 try {
155 future.get(60, TimeUnit.SECONDS);
156 } catch (final ExecutionException ex) {
157 Assertions.assertSame(boom, ex.getCause());
158 }
159 Assertions.assertTrue(future.isDone());
160 Assertions.assertFalse(future.isCancelled());
161 }
162
163 @Test
164 public void testAsyncCancelled() throws Exception {
165 final BasicFuture<Object> future = new BasicFuture<>(null);
166
167 final Thread t = new Thread(() -> {
168 try {
169 Thread.sleep(100);
170 future.cancel(true);
171 } catch (final InterruptedException ex) {
172 }
173 });
174 t.setDaemon(true);
175 t.start();
176 Assertions.assertThrows(CancellationException.class, () ->
177 future.get(60, TimeUnit.SECONDS));
178 }
179
180 @Test
181 public void testAsyncTimeout() throws Exception {
182 final BasicFuture<Object> future = new BasicFuture<>(null);
183 final Object result = new Object();
184
185 final Thread t = new Thread(() -> {
186 try {
187 Thread.sleep(200);
188 future.completed(result);
189 } catch (final InterruptedException ex) {
190 }
191 });
192 t.setDaemon(true);
193 t.start();
194 Assertions.assertThrows(TimeoutException.class, () ->
195 future.get(1, TimeUnit.MILLISECONDS));
196 }
197
198 @Test
199 public void testAsyncNegativeTimeout() throws Exception {
200 final BasicFuture<Object> future = new BasicFuture<>(null);
201 Assertions.assertThrows(TimeoutValueException.class, () ->
202 future.get(-1, TimeUnit.MILLISECONDS));
203 }
204
205 }