Coverage Report

Coverage Report - org.apache.maven.surefire.junitcore.NonConcurrentRunListener

Classes in this File

Line Coverage

Branch Coverage

Complexity

NonConcurrentRunListener

0/41

0/14

1,692

 package org.apache.maven.surefire.junitcore;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import org.apache.maven.surefire.common.junit4.JUnit4RunListener;
 import org.apache.maven.surefire.report.ConsoleOutputReceiver;
 import org.apache.maven.surefire.report.RunListener;
 import org.apache.maven.surefire.report.SimpleReportEntry;
 import org.apache.maven.surefire.testset.TestSetFailedException;
 import org.junit.runner.Description;
 import org.junit.runner.Result;
 import org.junit.runner.notification.Failure;
 
 /**
  * A class to be used when there is no JUnit parallelism (methods or/and class). This allow to workaround JUnit
  * limitation a la Junit4 provider. Specifically, we can redirect properly the output even if we don't have class
  * demarcation in JUnit. It works when if there is a JVM instance per test run, i.e. with forkMode=always or perthread.
  */
 public class NonConcurrentRunListener
     extends JUnit4RunListener
     implements ConsoleOutputReceiver
 {
 
     private Description currentTestSetDescription;
 
     private Description lastFinishedDescription;
 
     public NonConcurrentRunListener( RunListener reporter )
         throws TestSetFailedException
     {
         super( reporter );
     }
 
     public synchronized void writeTestOutput( byte[] buf, int off, int len, boolean stdout )
     {
         // We can write immediately: no parallelism and a single class.
         ( (ConsoleOutputReceiver) reporter ).writeTestOutput( buf, off, len, stdout );
     }
 
     protected SimpleReportEntry createReportEntry( Description description )
     {
         return new SimpleReportEntry( description.getClassName(), description.getDisplayName()/*
                                                                                                * , (int) (
                                                                                                * System.currentTimeMillis
                                                                                                * () - startTime )
                                                                                                */);
     }
 
     protected SimpleReportEntry createReportEntryForTestSet( Description description )
     {
         return new SimpleReportEntry( description.getClassName(), description.getClassName() /*
                                                                                               * , (int) (
                                                                                               * System.currentTimeMillis
                                                                                               * () - startTime )
                                                                                               */);
     }
 
     @Override
     public void testStarted( Description description )
         throws Exception
     {
         finishLastTestSetIfNeccessary( description );
         super.testStarted( description );
     }
 
     private void finishLastTestSetIfNeccessary( Description description )
     {
         if ( describesNewTestSet( description ) )
         {
             currentTestSetDescription = description;
             if ( lastFinishedDescription != null )
             {
                 reporter.testSetCompleted( createReportEntryForTestSet( lastFinishedDescription ) );
                 lastFinishedDescription = null;
             }
             reporter.testSetStarting( createReportEntryForTestSet( description ) );
         }
     }
 
     private boolean describesNewTestSet( Description description )
     {
         if ( currentTestSetDescription != null )
         {
             if ( null != description.getTestClass() )
             {
                 return !description.getTestClass().equals( currentTestSetDescription.getTestClass() );
             }
             else if ( description.isSuite() )
             {
                 return description.getChildren().equals( currentTestSetDescription.getChildren() );
             }
             
             return false;
         }
 
         return true;
     }
 
     @Override
     public void testFinished( Description description )
         throws Exception
     {
         super.testFinished( description );
         this.lastFinishedDescription = description;
     }
 
     @Override
     public void testIgnored( Description description )
         throws Exception
     {
         finishLastTestSetIfNeccessary( description );
 
         super.testIgnored( description );
         this.lastFinishedDescription = description;
     }
 
     @Override
     public void testFailure( Failure failure )
         throws Exception
     {
         super.testFailure( failure );
         this.lastFinishedDescription = failure.getDescription();
     }
 
     @Override
     public void testAssumptionFailure( Failure failure )
     {
         super.testAssumptionFailure( failure );
         this.lastFinishedDescription = failure.getDescription();
     }
 
     @Override
     public void testRunStarted( Description description )
         throws Exception
     {
     }
 
     @Override
     public void testRunFinished( Result result )
         throws Exception
     {
         if ( lastFinishedDescription != null )
         {
             reporter.testSetCompleted( createReportEntryForTestSet( lastFinishedDescription ) );
             lastFinishedDescription = null;
         }
     }
 }

1		package org.apache.maven.surefire.junitcore;
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.surefire.common.junit4.JUnit4RunListener;
23		import org.apache.maven.surefire.report.ConsoleOutputReceiver;
24		import org.apache.maven.surefire.report.RunListener;
25		import org.apache.maven.surefire.report.SimpleReportEntry;
26		import org.apache.maven.surefire.testset.TestSetFailedException;
27		import org.junit.runner.Description;
28		import org.junit.runner.Result;
29		import org.junit.runner.notification.Failure;
30
31		/**
32		* A class to be used when there is no JUnit parallelism (methods or/and class). This allow to workaround JUnit
33		* limitation a la Junit4 provider. Specifically, we can redirect properly the output even if we don't have class
34		* demarcation in JUnit. It works when if there is a JVM instance per test run, i.e. with forkMode=always or perthread.
35		*/
36		public class NonConcurrentRunListener
37		extends JUnit4RunListener
38		implements ConsoleOutputReceiver
39		{
40
41		private Description currentTestSetDescription;
42
43		private Description lastFinishedDescription;
44
45		public NonConcurrentRunListener( RunListener reporter )
46		throws TestSetFailedException
47		{
48	0	super( reporter );
49	0	}
50
51		public synchronized void writeTestOutput( byte[] buf, int off, int len, boolean stdout )
52		{
53		// We can write immediately: no parallelism and a single class.
54	0	( (ConsoleOutputReceiver) reporter ).writeTestOutput( buf, off, len, stdout );
55	0	}
56
57		protected SimpleReportEntry createReportEntry( Description description )
58		{
59	0	return new SimpleReportEntry( description.getClassName(), description.getDisplayName()/*
60		* , (int) (
61		* System.currentTimeMillis
62		* () - startTime )
63		*/);
64		}
65
66		protected SimpleReportEntry createReportEntryForTestSet( Description description )
67		{
68	0	return new SimpleReportEntry( description.getClassName(), description.getClassName() /*
69		* , (int) (
70		* System.currentTimeMillis
71		* () - startTime )
72		*/);
73		}
74
75		@Override
76		public void testStarted( Description description )
77		throws Exception
78		{
79	0	finishLastTestSetIfNeccessary( description );
80	0	super.testStarted( description );
81	0	}
82
83		private void finishLastTestSetIfNeccessary( Description description )
84		{
85	0	if ( describesNewTestSet( description ) )
86		{
87	0	currentTestSetDescription = description;
88	0	if ( lastFinishedDescription != null )
89		{
90	0	reporter.testSetCompleted( createReportEntryForTestSet( lastFinishedDescription ) );
91	0	lastFinishedDescription = null;
92		}
93	0	reporter.testSetStarting( createReportEntryForTestSet( description ) );
94		}
95	0	}
96
97		private boolean describesNewTestSet( Description description )
98		{
99	0	if ( currentTestSetDescription != null )
100		{
101	0	if ( null != description.getTestClass() )
102		{
103	0	return !description.getTestClass().equals( currentTestSetDescription.getTestClass() );
104		}
105	0	else if ( description.isSuite() )
106		{
107	0	return description.getChildren().equals( currentTestSetDescription.getChildren() );
108		}
109
110	0	return false;
111		}
112
113	0	return true;
114		}
115
116		@Override
117		public void testFinished( Description description )
118		throws Exception
119		{
120	0	super.testFinished( description );
121	0	this.lastFinishedDescription = description;
122	0	}
123
124		@Override
125		public void testIgnored( Description description )
126		throws Exception
127		{
128	0	finishLastTestSetIfNeccessary( description );
129
130	0	super.testIgnored( description );
131	0	this.lastFinishedDescription = description;
132	0	}
133
134		@Override
135		public void testFailure( Failure failure )
136		throws Exception
137		{
138	0	super.testFailure( failure );
139	0	this.lastFinishedDescription = failure.getDescription();
140	0	}
141
142		@Override
143		public void testAssumptionFailure( Failure failure )
144		{
145	0	super.testAssumptionFailure( failure );
146	0	this.lastFinishedDescription = failure.getDescription();
147	0	}
148
149		@Override
150		public void testRunStarted( Description description )
151		throws Exception
152		{
153	0	}
154
155		@Override
156		public void testRunFinished( Result result )
157		throws Exception
158		{
159	0	if ( lastFinishedDescription != null )
160		{
161	0	reporter.testSetCompleted( createReportEntryForTestSet( lastFinishedDescription ) );
162	0	lastFinishedDescription = null;
163		}
164	0	}
165		}