package org.apache.maven.surefire.report;

 /*

  * 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.util.internal.ByteBuffer;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 /**

  * Reports data for a single test set.

  * <p/>

  * Synchronization/Threading note:

  * <p/>

  * This design is really only good for single-threaded test execution. With the use of the additional

  * SynchronizedReporterManager you can get a buggy version that sort-of supports multithreading.

  * <p/>

  * The underlying providers are singletons and keep state per ReporterManager instance

  * <p/>

  * The solution to this problem involves making a clearer separation between test-result collection and reporting,

  * preferably removing singleton state approach out of the reporting interface.

  * <p/>

  */

 public class TestSetRunListener

     implements RunListener, RunReporter, Reporter, ConsoleOutputReceiver

 {

     private final RunStatistics globalStats;

     private final MulticastingReporter multicastingReporter;

     private final List testStdOut = Collections.synchronizedList( new ArrayList() );

     private final List testStdErr = Collections.synchronizedList( new ArrayList() );

     public TestSetRunListener( List reports, RunStatistics globalStats )

     {

         multicastingReporter = new MulticastingReporter( reports );

         this.globalStats = globalStats;

     }

     public void writeMessage( String message )

     {

         multicastingReporter.writeMessage( message );

     }

     public void writeTestOutput( byte[] buf, int off, int len, boolean stdout )

     {

         ByteBuffer byteBuffer = new ByteBuffer( buf, off, len );

         if ( stdout )

         {

             testStdOut.add( byteBuffer );

         }

         else

         {

             testStdErr.add( byteBuffer );

         }

         multicastingReporter.writeMessage( new String( buf, off, len ) );

     }

     public void writeDetailMessage( String message )

     {

         multicastingReporter.writeDetailMessage( message );

     }

     // ----------------------------------------------------------------------

     // Run

     // ----------------------------------------------------------------------

     public void runStarting()

     {

         multicastingReporter.runStarting();

     }

     public void runCompleted()

     {

         multicastingReporter.runCompleted();

         multicastingReporter.writeFooter( "" );

         multicastingReporter.writeFooter( "Results :" );

         multicastingReporter.writeFooter( "" );

         if ( globalStats.hadFailures() )

         {

             multicastingReporter.writeFooter( "Failed tests: " );

             for ( Iterator iterator = this.globalStats.getFailureSources().iterator(); iterator.hasNext(); )

             {

                 multicastingReporter.writeFooter( "  " + iterator.next() );

             }

             multicastingReporter.writeFooter( "" );

         }

         if ( globalStats.hadErrors() )

         {

             writeFooter( "Tests in error: " );

             for ( Iterator iterator = this.globalStats.getErrorSources().iterator(); iterator.hasNext(); )

             {

                 multicastingReporter.writeFooter( "  " + iterator.next() );

             }

             multicastingReporter.writeFooter( "" );

         }

         multicastingReporter.writeFooter( globalStats.getSummary() );

         multicastingReporter.writeFooter( "" );

     }

     public void writeFooter( String footer )

     {

         multicastingReporter.writeFooter( footer );

     }

     public void testSetStarting( ReportEntry report )

         throws ReporterException

     {

         multicastingReporter.testSetStarting( report );

     }

     public void testSetCompleted( ReportEntry report )

     {

         multicastingReporter.testSetCompleted( report );

         multicastingReporter.reset();

     }

     // ----------------------------------------------------------------------

     // Test

     // ----------------------------------------------------------------------

     public void testStarting( ReportEntry report )

     {

         multicastingReporter.testStarting( report );

     }

     public void testSucceeded( ReportEntry report )

     {

         clearCapturedContent();

         globalStats.incrementCompletedCount();

         multicastingReporter.testSucceeded( report );

     }

     public void testError( ReportEntry reportEntry )

     {

         testError( reportEntry, getAsString( testStdOut ), getAsString( testStdErr ) );

     }

     public void testError( ReportEntry reportEntry, String stdOutLog, String stdErrLog )

     {

         multicastingReporter.testError( reportEntry, stdOutLog, stdErrLog );

         globalStats.incrementErrorsCount();

         globalStats.incrementCompletedCount();

         globalStats.addErrorSource( reportEntry.getName(), reportEntry.getStackTraceWriter() );

         clearCapturedContent();

     }

     public void testFailed( ReportEntry reportEntry )

     {

         testFailed( reportEntry, getAsString( testStdOut ), getAsString( testStdErr ) );

     }

     public void testFailed( ReportEntry reportEntry, String stdOutLog, String stdErrLog )

     {

         multicastingReporter.testFailed( reportEntry, stdOutLog, stdErrLog );

         globalStats.incrementFailureCount();

         globalStats.incrementCompletedCount();

         globalStats.addFailureSource( reportEntry.getName(), reportEntry.getStackTraceWriter() );

         clearCapturedContent();

     }

     // ----------------------------------------------------------------------

     // Counters

     // ----------------------------------------------------------------------

     public void testSkipped( ReportEntry report )

     {

         clearCapturedContent();

         globalStats.incrementSkippedCount();

         globalStats.incrementCompletedCount();

         multicastingReporter.testSkipped( report );

     }

     public void testAssumptionFailure( ReportEntry report )

     {

         testSkipped( report );

     }

     public void reset()

     {

         multicastingReporter.reset();

     }

     public String getAsString( List byteBufferList )

     {

         StringBuffer stringBuffer = new StringBuffer();

         for ( Iterator iter = byteBufferList.iterator(); iter.hasNext(); )

         {

             ByteBuffer byteBuffer = (ByteBuffer) iter.next();

             stringBuffer.append( byteBuffer.toString() );

         }

         return stringBuffer.toString();

     }

     public void clearCapturedContent()

     {

         testStdErr.clear();

         testStdOut.clear();

     }

 }