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