View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.maven.plugin.surefire.booterclient.output;
20  
21  import javax.annotation.Nonnull;
22  
23  import java.io.ByteArrayInputStream;
24  import java.io.Closeable;
25  import java.io.File;
26  import java.nio.channels.ReadableByteChannel;
27  import java.util.concurrent.BlockingQueue;
28  import java.util.concurrent.ConcurrentLinkedQueue;
29  import java.util.concurrent.LinkedBlockingQueue;
30  import java.util.concurrent.TimeUnit;
31  
32  import org.apache.maven.plugin.surefire.booterclient.MockReporter;
33  import org.apache.maven.plugin.surefire.booterclient.lazytestprovider.NotifiableTestStream;
34  import org.apache.maven.plugin.surefire.extensions.EventConsumerThread;
35  import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
36  import org.apache.maven.plugin.surefire.report.DefaultReporterFactory;
37  import org.apache.maven.surefire.api.booter.Shutdown;
38  import org.apache.maven.surefire.api.event.ConsoleDebugEvent;
39  import org.apache.maven.surefire.api.event.ConsoleErrorEvent;
40  import org.apache.maven.surefire.api.event.ConsoleInfoEvent;
41  import org.apache.maven.surefire.api.event.ConsoleWarningEvent;
42  import org.apache.maven.surefire.api.event.ControlByeEvent;
43  import org.apache.maven.surefire.api.event.ControlNextTestEvent;
44  import org.apache.maven.surefire.api.event.ControlStopOnNextTestEvent;
45  import org.apache.maven.surefire.api.event.Event;
46  import org.apache.maven.surefire.api.event.StandardStreamErrEvent;
47  import org.apache.maven.surefire.api.event.StandardStreamErrWithNewLineEvent;
48  import org.apache.maven.surefire.api.event.StandardStreamOutEvent;
49  import org.apache.maven.surefire.api.event.StandardStreamOutWithNewLineEvent;
50  import org.apache.maven.surefire.api.event.SystemPropertyEvent;
51  import org.apache.maven.surefire.api.event.TestAssumptionFailureEvent;
52  import org.apache.maven.surefire.api.event.TestErrorEvent;
53  import org.apache.maven.surefire.api.event.TestFailedEvent;
54  import org.apache.maven.surefire.api.event.TestSkippedEvent;
55  import org.apache.maven.surefire.api.event.TestStartingEvent;
56  import org.apache.maven.surefire.api.event.TestSucceededEvent;
57  import org.apache.maven.surefire.api.event.TestsetCompletedEvent;
58  import org.apache.maven.surefire.api.event.TestsetStartingEvent;
59  import org.apache.maven.surefire.api.fork.ForkNodeArguments;
60  import org.apache.maven.surefire.api.report.ReportEntry;
61  import org.apache.maven.surefire.api.report.SafeThrowable;
62  import org.apache.maven.surefire.api.report.SimpleReportEntry;
63  import org.apache.maven.surefire.api.report.StackTraceWriter;
64  import org.apache.maven.surefire.api.report.TestSetReportEntry;
65  import org.apache.maven.surefire.extensions.EventHandler;
66  import org.apache.maven.surefire.extensions.util.CountdownCloseable;
67  import org.junit.Test;
68  
69  import static java.nio.channels.Channels.newChannel;
70  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_DEBUG;
71  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_ERR;
72  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_INFO;
73  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_WARN;
74  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.SET_COMPLETED;
75  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.SET_STARTING;
76  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.STDERR;
77  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.STDOUT;
78  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_ASSUMPTION_FAIL;
79  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_ERROR;
80  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_FAILED;
81  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_SKIPPED;
82  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_STARTING;
83  import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_SUCCEEDED;
84  import static org.apache.maven.surefire.api.booter.ForkedProcessEventType.BOOTERCODE_BYE;
85  import static org.apache.maven.surefire.api.booter.ForkedProcessEventType.BOOTERCODE_CONSOLE_ERROR;
86  import static org.apache.maven.surefire.api.report.RunMode.NORMAL_RUN;
87  import static org.assertj.core.api.Assertions.assertThat;
88  import static org.mockito.Mockito.any;
89  import static org.mockito.Mockito.eq;
90  import static org.mockito.Mockito.mock;
91  import static org.mockito.Mockito.never;
92  import static org.mockito.Mockito.times;
93  import static org.mockito.Mockito.verify;
94  import static org.mockito.Mockito.verifyNoMoreInteractions;
95  import static org.mockito.Mockito.verifyZeroInteractions;
96  import static org.mockito.Mockito.when;
97  
98  /**
99   * Test for {@link ForkClient}.
100  *
101  * @author <a href="mailto:tibordigana@apache.org">Tibor Digana (tibor17)</a>
102  * @since 3.0.0-M4
103  */
104 public class ForkClientTest {
105     private static final int ELAPSED_TIME = 102;
106 
107     @Test(expected = NullPointerException.class)
108     public void shouldFailOnNPE() {
109         String cwd = System.getProperty("user.dir");
110         File target = new File(cwd, "target");
111         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
112         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
113         ForkClient client = new ForkClient(factory, null, 0);
114         client.handleEvent(null);
115     }
116 
117     @Test
118     public void shouldLogJvmMessage() throws Exception {
119         String nativeStream = "Listening for transport dt_socket at address: bla";
120         EH eventHandler = new EH();
121         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
122         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, true, true, true);
123         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
124         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
125         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
126             t.start();
127             countdown.awaitClosed();
128             assertThat(logger.info).hasSize(1).contains("Listening for transport dt_socket at address: bla");
129         }
130 
131         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
132 
133         assertThat(logger.isDebugEnabledCalled).isTrue();
134 
135         assertThat(logger.isInfoEnabledCalled).isTrue();
136     }
137 
138     @Test
139     public void shouldLogJvmError1() throws Exception {
140         String nativeStream = "\nCould not create the Java Virtual Machine\n";
141         EH eventHandler = new EH();
142         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
143         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
144         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
145         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
146         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
147             t.start();
148             countdown.awaitClosed();
149             assertThat(logger.error).hasSize(1).contains("Could not create the Java Virtual Machine");
150         }
151 
152         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
153     }
154 
155     @Test
156     public void shouldLogJvmError2() throws Exception {
157         String nativeStream = "\nError occurred during initialization of VM\n";
158         EH eventHandler = new EH();
159         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
160         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
161         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
162         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
163         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
164             t.start();
165             countdown.awaitClosed();
166             assertThat(logger.error).hasSize(1).contains("Error occurred during initialization of VM");
167         }
168 
169         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
170     }
171 
172     @Test
173     public void shouldLogJvmError3() throws Exception {
174         String nativeStream = "\nError: A fatal exception has occurred. Program will exit.\n";
175         EH eventHandler = new EH();
176         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
177         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
178         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
179         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
180         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
181             t.start();
182             countdown.awaitClosed();
183             assertThat(logger.error).hasSize(1).contains("Error: A fatal exception has occurred. Program will exit.");
184         }
185 
186         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
187     }
188 
189     @Test
190     public void shouldLogJvmError4() throws Exception {
191         String nativeStream = "\nCould not reserve enough space for object heap\n";
192         EH eventHandler = new EH();
193         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
194         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
195         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
196         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
197         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
198             t.start();
199             countdown.awaitClosed();
200             assertThat(logger.error).hasSize(1).contains("Could not reserve enough space for object heap");
201         }
202 
203         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
204     }
205 
206     @Test
207     public void shouldLogJvmError5() throws Exception {
208         String nativeStream = "\njava.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api";
209         EH eventHandler = new EH();
210         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
211         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
212         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
213         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
214         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
215             t.start();
216             countdown.awaitClosed();
217             assertThat(logger.error)
218                     .hasSize(1)
219                     .contains("java.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api");
220         }
221 
222         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
223     }
224 
225     @Test
226     public void shouldLogJvmError6() throws Exception {
227         String nativeStream = "\njava.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api";
228         EH eventHandler = new EH();
229         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
230         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
231         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
232         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
233         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
234             t.start();
235             countdown.awaitClosed();
236             assertThat(logger.error)
237                     .hasSize(1)
238                     .contains("java.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api");
239         }
240 
241         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
242     }
243 
244     @Test
245     public void shouldLogUnorderedErrors() throws Exception {
246         String nativeStream = "unordered error";
247         EH eventHandler = new EH();
248         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
249         ConsoleLoggerMock logger = new ConsoleLoggerMock(true, true, true, true);
250         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
251         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
252         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
253             t.start();
254             countdown.awaitClosed();
255             assertThat(logger.debug).hasSize(1).contains("unordered error");
256         }
257 
258         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
259 
260         assertThat(logger.isDebugEnabledCalled).isTrue();
261 
262         String msg =
263                 "Corrupted channel by directly writing to native stream in forked JVM 0. Stream 'unordered error'.";
264         assertThat(arguments.dumpStreamText).hasSize(1).contains(msg);
265 
266         assertThat(arguments.logWarningAtEnd).hasSize(1);
267         assertThat(arguments.logWarningAtEnd.peek())
268                 .startsWith("Corrupted channel by directly writing to native stream in forked JVM 0. "
269                         + "See FAQ web page and the dump file");
270     }
271 
272     @Test
273     public void shouldLogJvmMessageAndProcessEvent() throws Exception {
274         String nativeStream = "Listening for transport dt_socket at address: bla\n:maven-surefire-event:\u0003:bye:\n";
275         EH eventHandler = new EH();
276         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
277         ConsoleLoggerMock logger = new ConsoleLoggerMock(true, true, true, true);
278         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
279         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
280         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
281             t.start();
282 
283             Event event = eventHandler.pullEvent();
284             assertThat(event).isNotNull();
285             assertThat(event.isControlCategory()).isTrue();
286             assertThat(event.getEventType()).isEqualTo(BOOTERCODE_BYE);
287 
288             assertThat(logger.debug).hasSize(1).contains("Listening for transport dt_socket at address: bla");
289 
290             countdown.awaitClosed();
291         }
292 
293         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
294 
295         assertThat(logger.isDebugEnabledCalled).isTrue();
296     }
297 
298     @Test
299     public void shouldBePossibleToKill() {
300         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
301 
302         ForkClient client = new ForkClient(null, notifiableTestStream, 0);
303         client.kill();
304 
305         verify(notifiableTestStream, times(1)).shutdown(eq(Shutdown.KILL));
306     }
307 
308     @Test
309     public void shouldAcquireNextTest() {
310         String cwd = System.getProperty("user.dir");
311         File target = new File(cwd, "target");
312         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
313         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
314         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
315         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
316         client.handleEvent(new ControlNextTestEvent());
317         verify(notifiableTestStream, times(1)).provideNewTest();
318         verifyNoMoreInteractions(notifiableTestStream);
319         verifyZeroInteractions(factory);
320         assertThat(client.isSaidGoodBye()).isFalse();
321         assertThat(client.getErrorInFork()).isNull();
322         assertThat(client.isErrorInFork()).isFalse();
323         assertThat(client.hadTimeout()).isFalse();
324         assertThat(client.hasTestsInProgress()).isFalse();
325         assertThat(client.testsInProgress()).isEmpty();
326         assertThat(client.getTestVmSystemProperties()).isEmpty();
327     }
328 
329     @Test
330     public void shouldNotifyWithBye() {
331         String cwd = System.getProperty("user.dir");
332         File target = new File(cwd, "target");
333         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
334         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
335         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
336 
337         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
338         client.handleEvent(new ControlByeEvent());
339         client.kill();
340 
341         verify(notifiableTestStream, times(1)).acknowledgeByeEventReceived();
342         verify(notifiableTestStream, never()).shutdown(any(Shutdown.class));
343         verifyNoMoreInteractions(notifiableTestStream);
344         verifyZeroInteractions(factory);
345         assertThat(client.isSaidGoodBye()).isTrue();
346         assertThat(client.getErrorInFork()).isNull();
347         assertThat(client.isErrorInFork()).isFalse();
348         assertThat(client.hadTimeout()).isFalse();
349         assertThat(client.hasTestsInProgress()).isFalse();
350         assertThat(client.testsInProgress()).isEmpty();
351         assertThat(client.getTestVmSystemProperties()).isEmpty();
352     }
353 
354     @Test
355     public void shouldStopOnNextTest() {
356         String cwd = System.getProperty("user.dir");
357         File target = new File(cwd, "target");
358         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
359         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
360         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
361         final boolean[] verified = {false};
362         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
363         client.setStopOnNextTestListener(() -> verified[0] = true);
364         client.handleEvent(new ControlStopOnNextTestEvent());
365         verifyZeroInteractions(notifiableTestStream);
366         verifyZeroInteractions(factory);
367         assertThat(verified[0]).isTrue();
368         assertThat(client.isSaidGoodBye()).isFalse();
369         assertThat(client.getErrorInFork()).isNull();
370         assertThat(client.isErrorInFork()).isFalse();
371         assertThat(client.hadTimeout()).isFalse();
372         assertThat(client.hasTestsInProgress()).isFalse();
373         assertThat(client.testsInProgress()).isEmpty();
374         assertThat(client.getTestVmSystemProperties()).isEmpty();
375     }
376 
377     @Test
378     public void shouldReceiveStdOut() {
379         String cwd = System.getProperty("user.dir");
380         File target = new File(cwd, "target");
381         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
382         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
383         MockReporter receiver = new MockReporter();
384         when(factory.createTestReportListener()).thenReturn(receiver);
385         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
386         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
387         client.handleEvent(new StandardStreamOutEvent(NORMAL_RUN, 1L, "msg"));
388         verifyZeroInteractions(notifiableTestStream);
389         verify(factory, times(1)).createTestReportListener();
390         verifyNoMoreInteractions(factory);
391         assertThat(client.getReporter()).isNotNull();
392         assertThat(receiver.getEvents()).hasSize(1).contains(STDOUT);
393         assertThat(receiver.getData()).hasSize(1).contains("msg");
394         assertThat(client.isSaidGoodBye()).isFalse();
395         assertThat(client.getErrorInFork()).isNull();
396         assertThat(client.isErrorInFork()).isFalse();
397         assertThat(client.hadTimeout()).isFalse();
398         assertThat(client.hasTestsInProgress()).isFalse();
399         assertThat(client.testsInProgress()).isEmpty();
400         assertThat(client.getTestVmSystemProperties()).isEmpty();
401     }
402 
403     @Test
404     public void shouldReceiveStdOutNewLine() {
405         String cwd = System.getProperty("user.dir");
406         File target = new File(cwd, "target");
407         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
408         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
409         MockReporter receiver = new MockReporter();
410         when(factory.createTestReportListener()).thenReturn(receiver);
411         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
412         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
413         client.handleEvent(new StandardStreamOutWithNewLineEvent(NORMAL_RUN, 1L, "msg"));
414         verifyZeroInteractions(notifiableTestStream);
415         verify(factory, times(1)).createTestReportListener();
416         verifyNoMoreInteractions(factory);
417         assertThat(client.getReporter()).isNotNull();
418         assertThat(receiver.getEvents()).hasSize(1).contains(STDOUT);
419         assertThat(receiver.getData()).hasSize(1).contains("msg\n");
420         assertThat(client.isSaidGoodBye()).isFalse();
421         assertThat(client.getErrorInFork()).isNull();
422         assertThat(client.isErrorInFork()).isFalse();
423         assertThat(client.hadTimeout()).isFalse();
424         assertThat(client.hasTestsInProgress()).isFalse();
425         assertThat(client.testsInProgress()).isEmpty();
426         assertThat(client.getTestVmSystemProperties()).isEmpty();
427     }
428 
429     @Test
430     public void shouldReceiveStdErr() {
431         String cwd = System.getProperty("user.dir");
432         File target = new File(cwd, "target");
433         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
434         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
435         MockReporter receiver = new MockReporter();
436         when(factory.createTestReportListener()).thenReturn(receiver);
437         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
438         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
439         client.handleEvent(new StandardStreamErrEvent(NORMAL_RUN, 1L, "msg"));
440         verifyZeroInteractions(notifiableTestStream);
441         verify(factory, times(1)).createTestReportListener();
442         verifyNoMoreInteractions(factory);
443         assertThat(client.getReporter()).isNotNull();
444         assertThat(receiver.getEvents()).hasSize(1).contains(STDERR);
445         assertThat(receiver.getData()).hasSize(1).contains("msg");
446         assertThat(client.isSaidGoodBye()).isFalse();
447         assertThat(client.getErrorInFork()).isNull();
448         assertThat(client.isErrorInFork()).isFalse();
449         assertThat(client.hadTimeout()).isFalse();
450         assertThat(client.hasTestsInProgress()).isFalse();
451         assertThat(client.testsInProgress()).isEmpty();
452         assertThat(client.getTestVmSystemProperties()).isEmpty();
453     }
454 
455     @Test
456     public void shouldReceiveStdErrNewLine() {
457         String cwd = System.getProperty("user.dir");
458         File target = new File(cwd, "target");
459         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
460         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
461         MockReporter receiver = new MockReporter();
462         when(factory.createTestReportListener()).thenReturn(receiver);
463         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
464         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
465         client.handleEvent(new StandardStreamErrWithNewLineEvent(NORMAL_RUN, 1L, "msg"));
466         verifyZeroInteractions(notifiableTestStream);
467         verify(factory, times(1)).createTestReportListener();
468         verifyNoMoreInteractions(factory);
469         assertThat(client.getReporter()).isNotNull();
470         assertThat(receiver.getEvents()).hasSize(1).contains(STDERR);
471         assertThat(receiver.getData()).hasSize(1).contains("msg\n");
472         assertThat(client.isSaidGoodBye()).isFalse();
473         assertThat(client.getErrorInFork()).isNull();
474         assertThat(client.isErrorInFork()).isFalse();
475         assertThat(client.hadTimeout()).isFalse();
476         assertThat(client.hasTestsInProgress()).isFalse();
477         assertThat(client.testsInProgress()).isEmpty();
478         assertThat(client.getTestVmSystemProperties()).isEmpty();
479     }
480 
481     @Test
482     public void shouldLogConsoleError() {
483         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
484         MockReporter receiver = new MockReporter();
485         when(factory.createTestReportListener()).thenReturn(receiver);
486         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
487         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
488         StackTraceWriter stackTrace =
489                 new DeserializedStacktraceWriter("Listening for transport dt_socket at address: 5005", null, null);
490         Event event = new ConsoleErrorEvent(stackTrace);
491         client.handleEvent(event);
492         verifyZeroInteractions(notifiableTestStream);
493         verify(factory, times(1)).createTestReportListener();
494         verify(factory, times(1)).getReportsDirectory();
495         verifyNoMoreInteractions(factory);
496         assertThat(client.getReporter()).isNotNull();
497         assertThat(receiver.getEvents()).isNotEmpty();
498         assertThat(receiver.getEvents()).contains(CONSOLE_ERR);
499         assertThat(receiver.getData()).isNotEmpty();
500         assertThat(receiver.getData()).contains("Listening for transport dt_socket at address: 5005");
501         assertThat(client.isSaidGoodBye()).isFalse();
502         assertThat(client.isErrorInFork()).isFalse();
503         assertThat(client.getErrorInFork()).isNull();
504         assertThat(client.hadTimeout()).isFalse();
505         assertThat(client.hasTestsInProgress()).isFalse();
506         assertThat(client.testsInProgress()).isEmpty();
507         assertThat(client.getTestVmSystemProperties()).isEmpty();
508     }
509 
510     @Test
511     public void shouldLogConsoleErrorWithStackTrace() throws Exception {
512         String nativeStream = ":maven-surefire-event:\u0011:console-error-log:\u0005:UTF-8"
513                 + ":\u0000\u0000\u0000\u0032:Listening for transport dt_socket at address: 5005"
514                 + ":\u0000\u0000\u0000\u0002:s1:\u0000\u0000\u0000\u0002:s2:";
515         EH eventHandler = new EH();
516         CountdownCloseable countdown = new CountdownCloseable(mock(Closeable.class), 1);
517         ConsoleLoggerMock logger = new ConsoleLoggerMock(false, false, false, false);
518         ForkNodeArgumentsMock arguments = new ForkNodeArgumentsMock(logger, new File(""));
519         ReadableByteChannel channel = newChannel(new ByteArrayInputStream(nativeStream.getBytes()));
520         try (EventConsumerThread t = new EventConsumerThread("t", channel, eventHandler, countdown, arguments)) {
521             t.start();
522 
523             Event event = eventHandler.pullEvent();
524             assertThat(event.isConsoleErrorCategory()).isTrue();
525             assertThat(event.isConsoleCategory()).isTrue();
526             assertThat(event.getEventType()).isEqualTo(BOOTERCODE_CONSOLE_ERROR);
527 
528             ConsoleErrorEvent consoleEvent = (ConsoleErrorEvent) event;
529             assertThat(consoleEvent.getStackTraceWriter()).isNotNull();
530             assertThat(consoleEvent.getStackTraceWriter().getThrowable().getMessage())
531                     .isEqualTo("Listening for transport dt_socket at address: 5005");
532             assertThat(consoleEvent.getStackTraceWriter().smartTrimmedStackTrace())
533                     .isEqualTo("s1");
534             assertThat(consoleEvent.getStackTraceWriter().writeTraceToString()).isEqualTo("s2");
535 
536             countdown.awaitClosed();
537 
538             assertThat(logger.isCalled()).isFalse();
539         }
540 
541         assertThat(eventHandler.sizeOfEventCache()).isEqualTo(0);
542     }
543 
544     @Test
545     public void shouldLogConsoleWarning() {
546         String cwd = System.getProperty("user.dir");
547         File target = new File(cwd, "target");
548         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
549         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
550         MockReporter receiver = new MockReporter();
551         when(factory.createTestReportListener()).thenReturn(receiver);
552         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
553         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
554         client.handleEvent(new ConsoleWarningEvent("s1"));
555         verifyZeroInteractions(notifiableTestStream);
556         verify(factory, times(1)).createTestReportListener();
557         verifyNoMoreInteractions(factory);
558         assertThat(client.getReporter()).isNotNull();
559         assertThat(receiver.getEvents()).hasSize(1).contains(CONSOLE_WARN);
560         assertThat(receiver.getData()).hasSize(1).contains("s1");
561         assertThat(client.isSaidGoodBye()).isFalse();
562         assertThat(client.isErrorInFork()).isFalse();
563         assertThat(client.getErrorInFork()).isNull();
564         assertThat(client.hadTimeout()).isFalse();
565         assertThat(client.hasTestsInProgress()).isFalse();
566         assertThat(client.testsInProgress()).isEmpty();
567         assertThat(client.getTestVmSystemProperties()).isEmpty();
568     }
569 
570     @Test
571     public void shouldLogConsoleDebug() {
572         String cwd = System.getProperty("user.dir");
573         File target = new File(cwd, "target");
574         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
575         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
576         MockReporter receiver = new MockReporter();
577         when(factory.createTestReportListener()).thenReturn(receiver);
578         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
579         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
580         client.handleEvent(new ConsoleDebugEvent("s1"));
581         verifyZeroInteractions(notifiableTestStream);
582         verify(factory, times(1)).createTestReportListener();
583         verifyNoMoreInteractions(factory);
584         assertThat(client.getReporter()).isNotNull();
585         assertThat(receiver.getEvents()).hasSize(1).contains(CONSOLE_DEBUG);
586         assertThat(receiver.getData()).hasSize(1).contains("s1");
587         assertThat(client.isSaidGoodBye()).isFalse();
588         assertThat(client.isErrorInFork()).isFalse();
589         assertThat(client.getErrorInFork()).isNull();
590         assertThat(client.hadTimeout()).isFalse();
591         assertThat(client.hasTestsInProgress()).isFalse();
592         assertThat(client.testsInProgress()).isEmpty();
593         assertThat(client.getTestVmSystemProperties()).isEmpty();
594     }
595 
596     @Test
597     public void shouldLogConsoleInfo() {
598         String cwd = System.getProperty("user.dir");
599         File target = new File(cwd, "target");
600         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
601         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
602         MockReporter receiver = new MockReporter();
603         when(factory.createTestReportListener()).thenReturn(receiver);
604         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
605         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
606         client.handleEvent(new ConsoleInfoEvent("s1"));
607         verifyZeroInteractions(notifiableTestStream);
608         verify(factory, times(1)).createTestReportListener();
609         verifyNoMoreInteractions(factory);
610         assertThat(client.getReporter()).isNotNull();
611         assertThat(receiver.getEvents()).hasSize(1).contains(CONSOLE_INFO);
612         assertThat(receiver.getData()).hasSize(1).contains("s1");
613         assertThat(client.isSaidGoodBye()).isFalse();
614         assertThat(client.isErrorInFork()).isFalse();
615         assertThat(client.getErrorInFork()).isNull();
616         assertThat(client.hadTimeout()).isFalse();
617         assertThat(client.hasTestsInProgress()).isFalse();
618         assertThat(client.testsInProgress()).isEmpty();
619         assertThat(client.getTestVmSystemProperties()).isEmpty();
620     }
621 
622     @Test
623     public void shouldSendSystemProperty() {
624         String cwd = System.getProperty("user.dir");
625         File target = new File(cwd, "target");
626         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
627         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
628         MockReporter receiver = new MockReporter();
629         when(factory.createTestReportListener()).thenReturn(receiver);
630         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
631         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
632         client.handleEvent(new SystemPropertyEvent(NORMAL_RUN, 1L, "k1", "v1"));
633         verifyZeroInteractions(notifiableTestStream);
634         verifyZeroInteractions(factory);
635         assertThat(client.getReporter()).isNotNull();
636         assertThat(receiver.getEvents()).isEmpty();
637         assertThat(receiver.getData()).isEmpty();
638         assertThat(client.isSaidGoodBye()).isFalse();
639         assertThat(client.isErrorInFork()).isFalse();
640         assertThat(client.getErrorInFork()).isNull();
641         assertThat(client.hadTimeout()).isFalse();
642         assertThat(client.hasTestsInProgress()).isFalse();
643         assertThat(client.testsInProgress()).isEmpty();
644         assertThat(client.getTestVmSystemProperties()).hasSize(1);
645         assertThat(client.getTestVmSystemProperties()).containsEntry("k1", "v1");
646     }
647 
648     @Test
649     public void shouldSendTestsetStartingKilled() {
650         String cwd = System.getProperty("user.dir");
651         File target = new File(cwd, "target");
652         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
653         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
654         MockReporter receiver = new MockReporter();
655         when(factory.createTestReportListener()).thenReturn(receiver);
656         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
657 
658         final String exceptionMessage = "msg";
659         final String smartStackTrace = "MyTest:86 >> Error";
660         final String stackTrace = "trace line 1\ntrace line 2";
661         final String trimmedStackTrace = "trace line 1";
662 
663         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
664         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
665         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
666         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
667         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
668         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
669 
670         TestSetReportEntry reportEntry = mock(TestSetReportEntry.class);
671         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
672         when(reportEntry.getTestRunId()).thenReturn(1L);
673         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
674         when(reportEntry.getGroup()).thenReturn("this group");
675         when(reportEntry.getMessage()).thenReturn("some test");
676         when(reportEntry.getName()).thenReturn("my test");
677         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
678         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
679         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
680 
681         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
682         client.handleEvent(new TestsetStartingEvent(reportEntry));
683 
684         client.tryToTimeout(System.currentTimeMillis() + 1000L, 1);
685 
686         verify(notifiableTestStream).shutdown(Shutdown.KILL);
687         verifyNoMoreInteractions(notifiableTestStream);
688         verify(factory).createTestReportListener();
689         verifyNoMoreInteractions(factory);
690         assertThat(client.getReporter()).isNotNull();
691         assertThat(receiver.getEvents()).hasSize(1);
692         assertThat(receiver.getEvents()).contains(SET_STARTING);
693         assertThat(receiver.getData()).hasSize(1);
694         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
695         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
696         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isEqualTo("my test");
697         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
698         assertThat(((ReportEntry) receiver.getData().get(0)).getElapsed()).isEqualTo(ELAPSED_TIME);
699         assertThat(((ReportEntry) receiver.getData().get(0)).getMessage()).isEqualTo("some test");
700         assertThat(((ReportEntry) receiver.getData().get(0)).getGroup()).isEqualTo("this group");
701         assertThat(((ReportEntry) receiver.getData().get(0)).getStackTraceWriter())
702                 .isNotNull();
703         assertThat(((ReportEntry) receiver.getData().get(0))
704                         .getStackTraceWriter()
705                         .getThrowable()
706                         .getLocalizedMessage())
707                 .isEqualTo(exceptionMessage);
708         assertThat(((ReportEntry) receiver.getData().get(0))
709                         .getStackTraceWriter()
710                         .smartTrimmedStackTrace())
711                 .isEqualTo(smartStackTrace);
712         assertThat(((ReportEntry) receiver.getData().get(0))
713                         .getStackTraceWriter()
714                         .writeTraceToString())
715                 .isEqualTo(stackTrace);
716         assertThat(((ReportEntry) receiver.getData().get(0))
717                         .getStackTraceWriter()
718                         .writeTrimmedTraceToString())
719                 .isEqualTo(trimmedStackTrace);
720         assertThat(client.isSaidGoodBye()).isFalse();
721         assertThat(client.isErrorInFork()).isFalse();
722         assertThat(client.getErrorInFork()).isNull();
723         assertThat(client.hadTimeout()).isTrue();
724         assertThat(client.hasTestsInProgress()).isFalse();
725         assertThat(client.testsInProgress()).isEmpty();
726         assertThat(client.getTestVmSystemProperties()).isEmpty();
727         assertThat(client.getTestVmSystemProperties()).isEmpty();
728     }
729 
730     @Test
731     public void shouldSendTestsetStarting() {
732         String cwd = System.getProperty("user.dir");
733         File target = new File(cwd, "target");
734         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
735         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
736         MockReporter receiver = new MockReporter();
737         when(factory.createTestReportListener()).thenReturn(receiver);
738         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
739 
740         final String exceptionMessage = "msg";
741         final String smartStackTrace = "MyTest:86 >> Error";
742         final String stackTrace = "trace line 1\ntrace line 2";
743         final String trimmedStackTrace = "trace line 1";
744 
745         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
746         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
747         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
748         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
749         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
750         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
751 
752         TestSetReportEntry reportEntry = mock(TestSetReportEntry.class);
753         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
754         when(reportEntry.getTestRunId()).thenReturn(1L);
755         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
756         when(reportEntry.getGroup()).thenReturn("this group");
757         when(reportEntry.getMessage()).thenReturn("some test");
758         when(reportEntry.getName()).thenReturn("my test");
759         when(reportEntry.getNameText()).thenReturn("dn2");
760         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
761         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
762         when(reportEntry.getSourceText()).thenReturn("dn1");
763         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
764 
765         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
766         client.handleEvent(new TestsetStartingEvent(reportEntry));
767         client.tryToTimeout(System.currentTimeMillis(), 1);
768 
769         verifyZeroInteractions(notifiableTestStream);
770         verify(factory).createTestReportListener();
771         verifyNoMoreInteractions(factory);
772         assertThat(client.getReporter()).isNotNull();
773         assertThat(receiver.getEvents()).hasSize(1);
774         assertThat(receiver.getEvents()).contains(SET_STARTING);
775         assertThat(receiver.getData()).hasSize(1);
776         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
777         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isEqualTo("dn1");
778         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isEqualTo("my test");
779         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isEqualTo("dn2");
780         assertThat(((ReportEntry) receiver.getData().get(0)).getElapsed()).isEqualTo(ELAPSED_TIME);
781         assertThat(((ReportEntry) receiver.getData().get(0)).getMessage()).isEqualTo("some test");
782         assertThat(((ReportEntry) receiver.getData().get(0)).getGroup()).isEqualTo("this group");
783         assertThat(((ReportEntry) receiver.getData().get(0)).getStackTraceWriter())
784                 .isNotNull();
785         assertThat(((ReportEntry) receiver.getData().get(0))
786                         .getStackTraceWriter()
787                         .getThrowable()
788                         .getLocalizedMessage())
789                 .isEqualTo("msg");
790         assertThat(((ReportEntry) receiver.getData().get(0))
791                         .getStackTraceWriter()
792                         .smartTrimmedStackTrace())
793                 .isEqualTo(smartStackTrace);
794         assertThat(((ReportEntry) receiver.getData().get(0))
795                         .getStackTraceWriter()
796                         .writeTraceToString())
797                 .isEqualTo(stackTrace);
798         assertThat(((ReportEntry) receiver.getData().get(0))
799                         .getStackTraceWriter()
800                         .writeTrimmedTraceToString())
801                 .isEqualTo(trimmedStackTrace);
802         assertThat(client.isSaidGoodBye()).isFalse();
803         assertThat(client.isErrorInFork()).isFalse();
804         assertThat(client.getErrorInFork()).isNull();
805         assertThat(client.hadTimeout()).isFalse();
806         assertThat(client.hasTestsInProgress()).isFalse();
807         assertThat(client.testsInProgress()).isEmpty();
808         assertThat(client.getTestVmSystemProperties()).isEmpty();
809         assertThat(client.getTestVmSystemProperties()).isEmpty();
810         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
811     }
812 
813     @Test
814     public void shouldSendTestsetCompleted() {
815         String cwd = System.getProperty("user.dir");
816         File target = new File(cwd, "target");
817         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
818         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
819         MockReporter receiver = new MockReporter();
820         when(factory.createTestReportListener()).thenReturn(receiver);
821         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
822 
823         final String exceptionMessage = "msg";
824         final String smartStackTrace = "MyTest:86 >> Error";
825         final String stackTrace = "trace line 1\ntrace line 2";
826         final String trimmedStackTrace = "trace line 1";
827 
828         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
829         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
830         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
831         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
832         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
833         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
834 
835         TestSetReportEntry reportEntry = mock(TestSetReportEntry.class);
836         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
837         when(reportEntry.getTestRunId()).thenReturn(1L);
838         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
839         when(reportEntry.getGroup()).thenReturn("this group");
840         when(reportEntry.getMessage()).thenReturn("some test");
841         when(reportEntry.getName()).thenReturn("my test");
842         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
843         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
844         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
845 
846         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
847         client.handleEvent(new TestsetCompletedEvent(reportEntry));
848 
849         verifyZeroInteractions(notifiableTestStream);
850         verify(factory).createTestReportListener();
851         verifyNoMoreInteractions(factory);
852         assertThat(client.getReporter()).isNotNull();
853         assertThat(receiver.getEvents()).hasSize(1);
854         assertThat(receiver.getEvents()).contains(SET_COMPLETED);
855         assertThat(receiver.getData()).hasSize(1);
856         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
857         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
858         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isEqualTo("my test");
859         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
860         assertThat(((ReportEntry) receiver.getData().get(0)).getElapsed()).isEqualTo(ELAPSED_TIME);
861         assertThat(((ReportEntry) receiver.getData().get(0)).getMessage()).isEqualTo("some test");
862         assertThat(((ReportEntry) receiver.getData().get(0)).getGroup()).isEqualTo("this group");
863         assertThat(((ReportEntry) receiver.getData().get(0)).getStackTraceWriter())
864                 .isNotNull();
865         assertThat(((ReportEntry) receiver.getData().get(0))
866                         .getStackTraceWriter()
867                         .getThrowable()
868                         .getLocalizedMessage())
869                 .isEqualTo("msg");
870         assertThat(((ReportEntry) receiver.getData().get(0))
871                         .getStackTraceWriter()
872                         .smartTrimmedStackTrace())
873                 .isEqualTo("MyTest:86 >> Error");
874         assertThat(((ReportEntry) receiver.getData().get(0))
875                         .getStackTraceWriter()
876                         .writeTraceToString())
877                 .isEqualTo(stackTrace);
878         assertThat(((ReportEntry) receiver.getData().get(0))
879                         .getStackTraceWriter()
880                         .writeTrimmedTraceToString())
881                 .isEqualTo(trimmedStackTrace);
882         assertThat(client.isSaidGoodBye()).isFalse();
883         assertThat(client.isErrorInFork()).isFalse();
884         assertThat(client.getErrorInFork()).isNull();
885         assertThat(client.hadTimeout()).isFalse();
886         assertThat(client.hasTestsInProgress()).isFalse();
887         assertThat(client.testsInProgress()).isEmpty();
888         assertThat(client.getTestVmSystemProperties()).isEmpty();
889         assertThat(client.getTestVmSystemProperties()).isEmpty();
890         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
891     }
892 
893     @Test
894     public void shouldSendTestStarting() {
895         String cwd = System.getProperty("user.dir");
896         File target = new File(cwd, "target");
897         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
898         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
899         MockReporter receiver = new MockReporter();
900         when(factory.createTestReportListener()).thenReturn(receiver);
901         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
902 
903         final String exceptionMessage = "msg";
904         final String smartStackTrace = "MyTest:86 >> Error";
905         final String stackTrace = "trace line 1\ntrace line 2";
906         final String trimmedStackTrace = "trace line 1";
907 
908         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
909         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
910         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
911         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
912         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
913         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
914 
915         ReportEntry reportEntry = mock(ReportEntry.class);
916         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
917         when(reportEntry.getTestRunId()).thenReturn(1L);
918         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
919         when(reportEntry.getGroup()).thenReturn("this group");
920         when(reportEntry.getMessage()).thenReturn("some test");
921         when(reportEntry.getName()).thenReturn("my test");
922         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
923         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
924         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
925 
926         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
927         client.handleEvent(new TestStartingEvent(reportEntry));
928 
929         verifyZeroInteractions(notifiableTestStream);
930         verify(factory).createTestReportListener();
931         verifyNoMoreInteractions(factory);
932         assertThat(client.hasTestsInProgress()).isTrue();
933         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
934         assertThat(client.getReporter()).isNotNull();
935         assertThat(receiver.getEvents()).hasSize(1);
936         assertThat(receiver.getEvents()).contains(TEST_STARTING);
937         assertThat(receiver.getData()).hasSize(1);
938         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
939         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
940         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isEqualTo("my test");
941         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
942         assertThat(((ReportEntry) receiver.getData().get(0)).getElapsed()).isEqualTo(ELAPSED_TIME);
943         assertThat(((ReportEntry) receiver.getData().get(0)).getMessage()).isEqualTo("some test");
944         assertThat(((ReportEntry) receiver.getData().get(0)).getGroup()).isEqualTo("this group");
945         assertThat(((ReportEntry) receiver.getData().get(0)).getStackTraceWriter())
946                 .isNotNull();
947         assertThat(((ReportEntry) receiver.getData().get(0))
948                         .getStackTraceWriter()
949                         .getThrowable()
950                         .getLocalizedMessage())
951                 .isEqualTo("msg");
952         assertThat(((ReportEntry) receiver.getData().get(0))
953                         .getStackTraceWriter()
954                         .smartTrimmedStackTrace())
955                 .isEqualTo(smartStackTrace);
956         assertThat(((ReportEntry) receiver.getData().get(0))
957                         .getStackTraceWriter()
958                         .writeTraceToString())
959                 .isEqualTo(stackTrace);
960         assertThat(((ReportEntry) receiver.getData().get(0))
961                         .getStackTraceWriter()
962                         .writeTrimmedTraceToString())
963                 .isEqualTo(trimmedStackTrace);
964         assertThat(client.isSaidGoodBye()).isFalse();
965         assertThat(client.isErrorInFork()).isFalse();
966         assertThat(client.getErrorInFork()).isNull();
967         assertThat(client.hadTimeout()).isFalse();
968         assertThat(client.getTestVmSystemProperties()).isEmpty();
969         assertThat(client.getTestVmSystemProperties()).isEmpty();
970         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
971     }
972 
973     @Test
974     public void shouldSendTestSucceeded() {
975         String cwd = System.getProperty("user.dir");
976         File target = new File(cwd, "target");
977         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
978         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
979         MockReporter receiver = new MockReporter();
980         when(factory.createTestReportListener()).thenReturn(receiver);
981         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
982 
983         final String exceptionMessage = "msg";
984         final String smartStackTrace = "MyTest:86 >> Error";
985         final String stackTrace = "trace line 1\ntrace line 2";
986         final String trimmedStackTrace = "trace line 1";
987 
988         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
989         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
990         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
991         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
992         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
993         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
994 
995         ReportEntry reportEntry = mock(ReportEntry.class);
996         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
997         when(reportEntry.getTestRunId()).thenReturn(1L);
998         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
999         when(reportEntry.getGroup()).thenReturn("this group");
1000         when(reportEntry.getMessage()).thenReturn("some test");
1001         when(reportEntry.getName()).thenReturn("my test");
1002         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
1003         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
1004         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
1005 
1006         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
1007         SimpleReportEntry testStarted =
1008                 new SimpleReportEntry(NORMAL_RUN, 1L, reportEntry.getSourceName(), null, null, null);
1009         client.handleEvent(new TestStartingEvent(testStarted));
1010 
1011         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
1012 
1013         client.handleEvent(new TestSucceededEvent(reportEntry));
1014 
1015         verifyZeroInteractions(notifiableTestStream);
1016         verify(factory).createTestReportListener();
1017         verifyNoMoreInteractions(factory);
1018         assertThat(client.getReporter()).isNotNull();
1019         assertThat(receiver.getEvents()).hasSize(2);
1020         assertThat(receiver.getEvents()).contains(TEST_STARTING, TEST_SUCCEEDED);
1021         assertThat(receiver.getData()).hasSize(2);
1022         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
1023         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
1024         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isNull();
1025         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
1026         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceName()).isEqualTo("pkg.MyTest");
1027         assertThat(((ReportEntry) receiver.getData().get(1)).getName()).isEqualTo("my test");
1028         assertThat(((ReportEntry) receiver.getData().get(1)).getElapsed()).isEqualTo(ELAPSED_TIME);
1029         assertThat(((ReportEntry) receiver.getData().get(1)).getMessage()).isEqualTo("some test");
1030         assertThat(((ReportEntry) receiver.getData().get(1)).getGroup()).isEqualTo("this group");
1031         assertThat(((ReportEntry) receiver.getData().get(1)).getStackTraceWriter())
1032                 .isNotNull();
1033         assertThat(((ReportEntry) receiver.getData().get(1))
1034                         .getStackTraceWriter()
1035                         .getThrowable()
1036                         .getLocalizedMessage())
1037                 .isEqualTo("msg");
1038         assertThat(((ReportEntry) receiver.getData().get(1))
1039                         .getStackTraceWriter()
1040                         .smartTrimmedStackTrace())
1041                 .isEqualTo(smartStackTrace);
1042         assertThat(((ReportEntry) receiver.getData().get(1))
1043                         .getStackTraceWriter()
1044                         .writeTraceToString())
1045                 .isEqualTo(stackTrace);
1046         assertThat(((ReportEntry) receiver.getData().get(1))
1047                         .getStackTraceWriter()
1048                         .writeTrimmedTraceToString())
1049                 .isEqualTo(trimmedStackTrace);
1050         assertThat(client.isSaidGoodBye()).isFalse();
1051         assertThat(client.isErrorInFork()).isFalse();
1052         assertThat(client.getErrorInFork()).isNull();
1053         assertThat(client.hadTimeout()).isFalse();
1054         assertThat(client.hasTestsInProgress()).isFalse();
1055         assertThat(client.testsInProgress()).isEmpty();
1056         assertThat(client.getTestVmSystemProperties()).isEmpty();
1057         assertThat(client.getTestVmSystemProperties()).isEmpty();
1058         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
1059     }
1060 
1061     @Test
1062     public void shouldSendTestFailed() {
1063         String cwd = System.getProperty("user.dir");
1064         File target = new File(cwd, "target");
1065         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
1066         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
1067         MockReporter receiver = new MockReporter();
1068         when(factory.createTestReportListener()).thenReturn(receiver);
1069         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
1070 
1071         final String exceptionMessage = "msg";
1072         final String smartStackTrace = "MyTest:86 >> Error";
1073         final String stackTrace = "trace line 1\ntrace line 2";
1074         final String trimmedStackTrace = "trace line 1";
1075 
1076         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
1077         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
1078         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
1079         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
1080         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
1081         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
1082 
1083         ReportEntry reportEntry = mock(ReportEntry.class);
1084         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
1085         when(reportEntry.getTestRunId()).thenReturn(1L);
1086         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
1087         when(reportEntry.getGroup()).thenReturn("this group");
1088         when(reportEntry.getMessage()).thenReturn("some test");
1089         when(reportEntry.getName()).thenReturn("my test");
1090         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
1091         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
1092         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
1093 
1094         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
1095         SimpleReportEntry testClass =
1096                 new SimpleReportEntry(NORMAL_RUN, 1L, reportEntry.getSourceName(), null, null, null);
1097         client.handleEvent(new TestStartingEvent(testClass));
1098 
1099         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
1100 
1101         client.handleEvent(new TestFailedEvent(reportEntry));
1102 
1103         verifyZeroInteractions(notifiableTestStream);
1104         verify(factory).createTestReportListener();
1105         verifyNoMoreInteractions(factory);
1106         assertThat(client.getReporter()).isNotNull();
1107         assertThat(receiver.getEvents()).hasSize(2);
1108         assertThat(receiver.getEvents()).contains(TEST_STARTING, TEST_FAILED);
1109         assertThat(receiver.getData()).hasSize(2);
1110         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
1111         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
1112         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isNull();
1113         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
1114         assertThat(((ReportEntry) receiver.getData().get(0)).getStackTraceWriter())
1115                 .isNull();
1116         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceName()).isEqualTo("pkg.MyTest");
1117         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceText()).isNull();
1118         assertThat(((ReportEntry) receiver.getData().get(1)).getName()).isEqualTo("my test");
1119         assertThat(((ReportEntry) receiver.getData().get(1)).getNameText()).isNull();
1120         assertThat(((ReportEntry) receiver.getData().get(1)).getElapsed()).isEqualTo(ELAPSED_TIME);
1121         assertThat(((ReportEntry) receiver.getData().get(1)).getMessage()).isEqualTo("some test");
1122         assertThat(((ReportEntry) receiver.getData().get(1)).getGroup()).isEqualTo("this group");
1123         assertThat(((ReportEntry) receiver.getData().get(1)).getStackTraceWriter())
1124                 .isNotNull();
1125         assertThat(((ReportEntry) receiver.getData().get(1))
1126                         .getStackTraceWriter()
1127                         .getThrowable()
1128                         .getLocalizedMessage())
1129                 .isEqualTo("msg");
1130         assertThat(((ReportEntry) receiver.getData().get(1))
1131                         .getStackTraceWriter()
1132                         .smartTrimmedStackTrace())
1133                 .isEqualTo("MyTest:86 >> Error");
1134         assertThat(((ReportEntry) receiver.getData().get(1))
1135                         .getStackTraceWriter()
1136                         .writeTraceToString())
1137                 .isEqualTo(stackTrace);
1138         assertThat(((ReportEntry) receiver.getData().get(1))
1139                         .getStackTraceWriter()
1140                         .writeTrimmedTraceToString())
1141                 .isEqualTo(trimmedStackTrace);
1142         assertThat(client.isSaidGoodBye()).isFalse();
1143         assertThat(client.isErrorInFork()).isFalse();
1144         assertThat(client.getErrorInFork()).isNull();
1145         assertThat(client.hadTimeout()).isFalse();
1146         assertThat(client.hasTestsInProgress()).isFalse();
1147         assertThat(client.testsInProgress()).isEmpty();
1148         assertThat(client.getTestVmSystemProperties()).isEmpty();
1149         assertThat(client.getTestVmSystemProperties()).isEmpty();
1150         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
1151     }
1152 
1153     @Test
1154     public void shouldSendTestSkipped() {
1155         String cwd = System.getProperty("user.dir");
1156         File target = new File(cwd, "target");
1157         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
1158         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
1159         MockReporter receiver = new MockReporter();
1160         when(factory.createTestReportListener()).thenReturn(receiver);
1161         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
1162 
1163         final String exceptionMessage = "msg";
1164         final String smartStackTrace = "MyTest:86 >> Error";
1165         final String stackTrace = "trace line 1\ntrace line 2";
1166         final String trimmedStackTrace = "trace line 1";
1167 
1168         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
1169         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
1170         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
1171         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
1172         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
1173         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
1174 
1175         ReportEntry reportEntry = mock(ReportEntry.class);
1176         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
1177         when(reportEntry.getTestRunId()).thenReturn(1L);
1178         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
1179         when(reportEntry.getGroup()).thenReturn("this group");
1180         when(reportEntry.getMessage()).thenReturn("some test");
1181         when(reportEntry.getName()).thenReturn("my test");
1182         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
1183         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
1184         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
1185 
1186         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
1187         SimpleReportEntry testStarted =
1188                 new SimpleReportEntry(NORMAL_RUN, 1L, reportEntry.getSourceName(), null, null, null);
1189         client.handleEvent(new TestStartingEvent(testStarted));
1190 
1191         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
1192 
1193         client.handleEvent(new TestSkippedEvent(reportEntry));
1194 
1195         verifyZeroInteractions(notifiableTestStream);
1196         verify(factory).createTestReportListener();
1197         verifyNoMoreInteractions(factory);
1198         assertThat(client.getReporter()).isNotNull();
1199         assertThat(receiver.getEvents()).hasSize(2);
1200         assertThat(receiver.getEvents()).contains(TEST_STARTING, TEST_SKIPPED);
1201         assertThat(receiver.getData()).hasSize(2);
1202         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
1203         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
1204         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isNull();
1205         assertThat(((ReportEntry) receiver.getData().get(0)).getNameText()).isNull();
1206         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceName()).isEqualTo("pkg.MyTest");
1207         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceText()).isNull();
1208         assertThat(((ReportEntry) receiver.getData().get(1)).getName()).isEqualTo("my test");
1209         assertThat(((ReportEntry) receiver.getData().get(1)).getNameText()).isNull();
1210         assertThat(((ReportEntry) receiver.getData().get(1)).getElapsed()).isEqualTo(ELAPSED_TIME);
1211         assertThat(((ReportEntry) receiver.getData().get(1)).getMessage()).isEqualTo("some test");
1212         assertThat(((ReportEntry) receiver.getData().get(1)).getGroup()).isEqualTo("this group");
1213         assertThat(((ReportEntry) receiver.getData().get(1)).getStackTraceWriter())
1214                 .isNotNull();
1215         assertThat(((ReportEntry) receiver.getData().get(1))
1216                         .getStackTraceWriter()
1217                         .getThrowable()
1218                         .getLocalizedMessage())
1219                 .isEqualTo("msg");
1220         assertThat(((ReportEntry) receiver.getData().get(1))
1221                         .getStackTraceWriter()
1222                         .smartTrimmedStackTrace())
1223                 .isEqualTo(smartStackTrace);
1224         assertThat(((ReportEntry) receiver.getData().get(1))
1225                         .getStackTraceWriter()
1226                         .writeTraceToString())
1227                 .isEqualTo(stackTrace);
1228         assertThat(((ReportEntry) receiver.getData().get(1))
1229                         .getStackTraceWriter()
1230                         .writeTrimmedTraceToString())
1231                 .isEqualTo(trimmedStackTrace);
1232         assertThat(client.isSaidGoodBye()).isFalse();
1233         assertThat(client.isErrorInFork()).isFalse();
1234         assertThat(client.getErrorInFork()).isNull();
1235         assertThat(client.hadTimeout()).isFalse();
1236         assertThat(client.hasTestsInProgress()).isFalse();
1237         assertThat(client.testsInProgress()).isEmpty();
1238         assertThat(client.getTestVmSystemProperties()).isEmpty();
1239         assertThat(client.getTestVmSystemProperties()).isEmpty();
1240         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
1241     }
1242 
1243     @Test
1244     public void shouldSendTestError() {
1245         String cwd = System.getProperty("user.dir");
1246         File target = new File(cwd, "target");
1247         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
1248         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
1249         MockReporter receiver = new MockReporter();
1250         when(factory.createTestReportListener()).thenReturn(receiver);
1251         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
1252 
1253         final String exceptionMessage = "msg";
1254         final String smartStackTrace = "MyTest:86 >> Error";
1255         final String stackTrace = "trace line 1\ntrace line 2";
1256         final String trimmedStackTrace = "trace line 1";
1257 
1258         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
1259         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
1260         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
1261         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
1262         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
1263         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
1264 
1265         ReportEntry reportEntry = mock(ReportEntry.class);
1266         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
1267         when(reportEntry.getTestRunId()).thenReturn(1L);
1268         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
1269         when(reportEntry.getGroup()).thenReturn("this group");
1270         when(reportEntry.getMessage()).thenReturn("some test");
1271         when(reportEntry.getName()).thenReturn("my test");
1272         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
1273         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
1274         when(reportEntry.getSourceText()).thenReturn("display name");
1275         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
1276 
1277         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
1278         SimpleReportEntry testStarted = new SimpleReportEntry(
1279                 NORMAL_RUN, 1L, reportEntry.getSourceName(), reportEntry.getSourceText(), null, null);
1280         client.handleEvent(new TestStartingEvent(testStarted));
1281 
1282         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
1283 
1284         client.handleEvent(new TestErrorEvent(reportEntry));
1285 
1286         verifyZeroInteractions(notifiableTestStream);
1287         verify(factory).createTestReportListener();
1288         verifyNoMoreInteractions(factory);
1289         assertThat(client.getReporter()).isNotNull();
1290         assertThat(receiver.getEvents()).hasSize(2);
1291         assertThat(receiver.getEvents()).contains(TEST_STARTING, TEST_ERROR);
1292         assertThat(receiver.getData()).hasSize(2);
1293         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
1294         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isEqualTo("display name");
1295         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isNull();
1296         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceName()).isEqualTo("pkg.MyTest");
1297         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceText()).isEqualTo("display name");
1298         assertThat(((ReportEntry) receiver.getData().get(1)).getName()).isEqualTo("my test");
1299         assertThat(((ReportEntry) receiver.getData().get(1)).getElapsed()).isEqualTo(ELAPSED_TIME);
1300         assertThat(((ReportEntry) receiver.getData().get(1)).getMessage()).isEqualTo("some test");
1301         assertThat(((ReportEntry) receiver.getData().get(1)).getGroup()).isEqualTo("this group");
1302         assertThat(((ReportEntry) receiver.getData().get(1)).getStackTraceWriter())
1303                 .isNotNull();
1304         assertThat(((ReportEntry) receiver.getData().get(1))
1305                         .getStackTraceWriter()
1306                         .getThrowable()
1307                         .getLocalizedMessage())
1308                 .isEqualTo("msg");
1309         assertThat(((ReportEntry) receiver.getData().get(1))
1310                         .getStackTraceWriter()
1311                         .smartTrimmedStackTrace())
1312                 .isEqualTo(smartStackTrace);
1313         assertThat(((ReportEntry) receiver.getData().get(1))
1314                         .getStackTraceWriter()
1315                         .writeTraceToString())
1316                 .isEqualTo(stackTrace);
1317         assertThat(((ReportEntry) receiver.getData().get(1))
1318                         .getStackTraceWriter()
1319                         .writeTrimmedTraceToString())
1320                 .isEqualTo(trimmedStackTrace);
1321         assertThat(client.isSaidGoodBye()).isFalse();
1322         assertThat(client.isErrorInFork()).isFalse();
1323         assertThat(client.getErrorInFork()).isNull();
1324         assertThat(client.hadTimeout()).isFalse();
1325         assertThat(client.hasTestsInProgress()).isFalse();
1326         assertThat(client.testsInProgress()).isEmpty();
1327         assertThat(client.getTestVmSystemProperties()).isEmpty();
1328         assertThat(client.getTestVmSystemProperties()).isEmpty();
1329         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
1330     }
1331 
1332     @Test
1333     public void shouldSendTestAssumptionFailure() {
1334         String cwd = System.getProperty("user.dir");
1335         File target = new File(cwd, "target");
1336         DefaultReporterFactory factory = mock(DefaultReporterFactory.class);
1337         when(factory.getReportsDirectory()).thenReturn(new File(target, "surefire-reports"));
1338         MockReporter receiver = new MockReporter();
1339         when(factory.createTestReportListener()).thenReturn(receiver);
1340         NotifiableTestStream notifiableTestStream = mock(NotifiableTestStream.class);
1341 
1342         final String exceptionMessage = "msg";
1343         final String smartStackTrace = "MyTest:86 >> Error";
1344         final String stackTrace = "trace line 1\ntrace line 2";
1345         final String trimmedStackTrace = "trace line 1";
1346 
1347         SafeThrowable safeThrowable = new SafeThrowable(new Exception(exceptionMessage));
1348         StackTraceWriter stackTraceWriter = mock(StackTraceWriter.class);
1349         when(stackTraceWriter.getThrowable()).thenReturn(safeThrowable);
1350         when(stackTraceWriter.smartTrimmedStackTrace()).thenReturn(smartStackTrace);
1351         when(stackTraceWriter.writeTrimmedTraceToString()).thenReturn(trimmedStackTrace);
1352         when(stackTraceWriter.writeTraceToString()).thenReturn(stackTrace);
1353 
1354         ReportEntry reportEntry = mock(ReportEntry.class);
1355         when(reportEntry.getRunMode()).thenReturn(NORMAL_RUN);
1356         when(reportEntry.getTestRunId()).thenReturn(1L);
1357         when(reportEntry.getElapsed()).thenReturn(ELAPSED_TIME);
1358         when(reportEntry.getGroup()).thenReturn("this group");
1359         when(reportEntry.getMessage()).thenReturn("some test");
1360         when(reportEntry.getName()).thenReturn("my test");
1361         when(reportEntry.getNameText()).thenReturn("display name");
1362         when(reportEntry.getNameWithGroup()).thenReturn("name with group");
1363         when(reportEntry.getSourceName()).thenReturn("pkg.MyTest");
1364         when(reportEntry.getStackTraceWriter()).thenReturn(stackTraceWriter);
1365 
1366         ForkClient client = new ForkClient(factory, notifiableTestStream, 0);
1367         SimpleReportEntry testStarted =
1368                 new SimpleReportEntry(NORMAL_RUN, 1L, reportEntry.getSourceName(), null, null, null);
1369         client.handleEvent(new TestStartingEvent(testStarted));
1370 
1371         assertThat(client.testsInProgress()).hasSize(1).contains("pkg.MyTest");
1372 
1373         client.handleEvent(new TestAssumptionFailureEvent(reportEntry));
1374 
1375         verifyZeroInteractions(notifiableTestStream);
1376         verify(factory).createTestReportListener();
1377         verifyNoMoreInteractions(factory);
1378         assertThat(client.getReporter()).isNotNull();
1379         assertThat(receiver.getEvents()).hasSize(2);
1380         assertThat(receiver.getEvents()).contains(TEST_STARTING, TEST_ASSUMPTION_FAIL);
1381         assertThat(receiver.getData()).hasSize(2);
1382         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceName()).isEqualTo("pkg.MyTest");
1383         assertThat(((ReportEntry) receiver.getData().get(0)).getSourceText()).isNull();
1384         assertThat(((ReportEntry) receiver.getData().get(0)).getName()).isNull();
1385         assertThat(((ReportEntry) receiver.getData().get(1)).getSourceName()).isEqualTo("pkg.MyTest");
1386         assertThat(((ReportEntry) receiver.getData().get(1)).getName()).isEqualTo("my test");
1387         assertThat(((ReportEntry) receiver.getData().get(1)).getNameText()).isEqualTo("display name");
1388         assertThat(((ReportEntry) receiver.getData().get(1)).getElapsed()).isEqualTo(ELAPSED_TIME);
1389         assertThat(((ReportEntry) receiver.getData().get(1)).getMessage()).isEqualTo("some test");
1390         assertThat(((ReportEntry) receiver.getData().get(1)).getGroup()).isEqualTo("this group");
1391         assertThat(((ReportEntry) receiver.getData().get(1)).getStackTraceWriter())
1392                 .isNotNull();
1393         assertThat(((ReportEntry) receiver.getData().get(1))
1394                         .getStackTraceWriter()
1395                         .getThrowable()
1396                         .getLocalizedMessage())
1397                 .isEqualTo("msg");
1398         assertThat(((ReportEntry) receiver.getData().get(1))
1399                         .getStackTraceWriter()
1400                         .smartTrimmedStackTrace())
1401                 .isEqualTo(smartStackTrace);
1402         assertThat(((ReportEntry) receiver.getData().get(1))
1403                         .getStackTraceWriter()
1404                         .writeTraceToString())
1405                 .isEqualTo(stackTrace);
1406         assertThat(((ReportEntry) receiver.getData().get(1))
1407                         .getStackTraceWriter()
1408                         .writeTrimmedTraceToString())
1409                 .isEqualTo(trimmedStackTrace);
1410         assertThat(client.isSaidGoodBye()).isFalse();
1411         assertThat(client.isErrorInFork()).isFalse();
1412         assertThat(client.getErrorInFork()).isNull();
1413         assertThat(client.hadTimeout()).isFalse();
1414         assertThat(client.hasTestsInProgress()).isFalse();
1415         assertThat(client.testsInProgress()).isEmpty();
1416         assertThat(client.getTestVmSystemProperties()).isEmpty();
1417         assertThat(client.getTestVmSystemProperties()).isEmpty();
1418         assertThat(client.getDefaultReporterFactory()).isSameAs(factory);
1419     }
1420 
1421     private static class EH implements EventHandler<Event> {
1422         private final BlockingQueue<Event> cache = new LinkedBlockingQueue<>(1);
1423 
1424         Event pullEvent() throws InterruptedException {
1425             return cache.poll(1, TimeUnit.MINUTES);
1426         }
1427 
1428         int sizeOfEventCache() {
1429             return cache.size();
1430         }
1431 
1432         @Override
1433         public void handleEvent(@Nonnull Event event) {
1434             cache.add(event);
1435         }
1436     }
1437 
1438     /**
1439      * Threadsafe impl. Mockito and Powermock are not thread-safe.
1440      */
1441     private static class ForkNodeArgumentsMock implements ForkNodeArguments {
1442         private final ConcurrentLinkedQueue<String> dumpStreamText = new ConcurrentLinkedQueue<>();
1443         private final ConcurrentLinkedQueue<String> logWarningAtEnd = new ConcurrentLinkedQueue<>();
1444         private final ConsoleLogger logger;
1445         private final File dumpStreamTextFile;
1446 
1447         ForkNodeArgumentsMock(ConsoleLogger logger, File dumpStreamTextFile) {
1448             this.logger = logger;
1449             this.dumpStreamTextFile = dumpStreamTextFile;
1450         }
1451 
1452         @Nonnull
1453         @Override
1454         public String getSessionId() {
1455             throw new UnsupportedOperationException();
1456         }
1457 
1458         @Override
1459         public int getForkChannelId() {
1460             return 0;
1461         }
1462 
1463         @Nonnull
1464         @Override
1465         public File dumpStreamText(@Nonnull String text) {
1466             dumpStreamText.add(text);
1467             return dumpStreamTextFile;
1468         }
1469 
1470         @Nonnull
1471         @Override
1472         public File dumpStreamException(@Nonnull Throwable t) {
1473             throw new UnsupportedOperationException();
1474         }
1475 
1476         @Override
1477         public void logWarningAtEnd(@Nonnull String text) {
1478             logWarningAtEnd.add(text);
1479         }
1480 
1481         @Nonnull
1482         @Override
1483         public ConsoleLogger getConsoleLogger() {
1484             return logger;
1485         }
1486 
1487         @Nonnull
1488         @Override
1489         public Object getConsoleLock() {
1490             return logger;
1491         }
1492 
1493         boolean isCalled() {
1494             return !dumpStreamText.isEmpty() || !logWarningAtEnd.isEmpty();
1495         }
1496 
1497         @Override
1498         public File getEventStreamBinaryFile() {
1499             return null;
1500         }
1501 
1502         @Override
1503         public File getCommandStreamBinaryFile() {
1504             return null;
1505         }
1506     }
1507 
1508     /**
1509      * Threadsafe impl. Mockito and Powermock are not thread-safe.
1510      */
1511     private static class ConsoleLoggerMock implements ConsoleLogger {
1512         final ConcurrentLinkedQueue<String> debug = new ConcurrentLinkedQueue<>();
1513         final ConcurrentLinkedQueue<String> info = new ConcurrentLinkedQueue<>();
1514         final ConcurrentLinkedQueue<String> error = new ConcurrentLinkedQueue<>();
1515         final boolean isDebug;
1516         final boolean isInfo;
1517         final boolean isWarning;
1518         final boolean isError;
1519         private volatile boolean called;
1520         private volatile boolean isDebugEnabledCalled;
1521         private volatile boolean isInfoEnabledCalled;
1522 
1523         ConsoleLoggerMock(boolean isDebug, boolean isInfo, boolean isWarning, boolean isError) {
1524             this.isDebug = isDebug;
1525             this.isInfo = isInfo;
1526             this.isWarning = isWarning;
1527             this.isError = isError;
1528         }
1529 
1530         @Override
1531         public synchronized boolean isDebugEnabled() {
1532             isDebugEnabledCalled = true;
1533             called = true;
1534             return isDebug;
1535         }
1536 
1537         @Override
1538         public synchronized void debug(String message) {
1539             debug.add(message);
1540             called = true;
1541         }
1542 
1543         @Override
1544         public synchronized boolean isInfoEnabled() {
1545             isInfoEnabledCalled = true;
1546             called = true;
1547             return isInfo;
1548         }
1549 
1550         @Override
1551         public synchronized void info(String message) {
1552             info.add(message);
1553             called = true;
1554         }
1555 
1556         @Override
1557         public synchronized boolean isWarnEnabled() {
1558             called = true;
1559             return isWarning;
1560         }
1561 
1562         @Override
1563         public synchronized void warning(String message) {
1564             called = true;
1565         }
1566 
1567         @Override
1568         public synchronized boolean isErrorEnabled() {
1569             called = true;
1570             return isError;
1571         }
1572 
1573         @Override
1574         public synchronized void error(String message) {
1575             error.add(message);
1576             called = true;
1577         }
1578 
1579         @Override
1580         public synchronized void error(String message, Throwable t) {
1581             called = true;
1582         }
1583 
1584         @Override
1585         public synchronized void error(Throwable t) {
1586             called = true;
1587         }
1588 
1589         synchronized boolean isCalled() {
1590             return called;
1591         }
1592     }
1593 }