Coverage Report - org.apache.maven.plugin.surefire.booterclient.output.ThreadedStreamConsumer
 
Classes in this File Line Coverage Branch Coverage Complexity
ThreadedStreamConsumer
0%
0/16
0%
0/2
2
ThreadedStreamConsumer$Pumper
0%
0/13
0%
0/2
2
 
 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.util.internal.BlockingQueue;
 23  
 import org.apache.maven.plugin.surefire.util.internal.Java15BlockingQueue;
 24  
 import org.apache.maven.shared.utils.cli.StreamConsumer;
 25  
 
 26  
 /**
 27  
  * Knows how to reconstruct *all* the state transmitted over stdout by the forked process.
 28  
  *
 29  
  * @author Kristian Rosenvold
 30  
  */
 31  
 public class ThreadedStreamConsumer
 32  
     implements StreamConsumer
 33  
 {
 34  
 
 35  0
     private final BlockingQueue items = new Java15BlockingQueue();
 36  
 
 37  
     private static final String poison = "Pioson";
 38  
 
 39  
     private final Thread thread;
 40  
 
 41  
     private final Pumper pumper;
 42  
 
 43  
     static class Pumper
 44  
         implements Runnable
 45  
     {
 46  
         private final BlockingQueue queue;
 47  
 
 48  
         private final StreamConsumer target;
 49  
 
 50  
         private volatile InterruptedException interruptedException;
 51  
 
 52  
 
 53  
         Pumper( BlockingQueue queue, StreamConsumer target )
 54  0
         {
 55  0
             this.queue = queue;
 56  0
             this.target = target;
 57  0
         }
 58  
 
 59  
         public void run()
 60  
         {
 61  
             try
 62  
             {
 63  0
                 String item = queue.take();
 64  
                 //noinspection StringEquality
 65  0
                 while ( item != poison )
 66  
                 {
 67  0
                     target.consumeLine( item );
 68  0
                     item = queue.take();
 69  
                 }
 70  
             }
 71  0
             catch ( InterruptedException e )
 72  
             {
 73  0
                 this.interruptedException = e;
 74  0
             }
 75  0
         }
 76  
 
 77  
         public InterruptedException getInterruptedException()
 78  
         {
 79  0
             return interruptedException;
 80  
         }
 81  
     }
 82  
 
 83  
     public ThreadedStreamConsumer( StreamConsumer target )
 84  0
     {
 85  0
         pumper = new Pumper( items, target );
 86  0
         thread = new Thread( pumper, "ThreadedStreamConsumer" );
 87  0
         thread.start();
 88  0
     }
 89  
 
 90  
     public void consumeLine( String s )
 91  
     {
 92  0
         items.add( s );
 93  0
     }
 94  
 
 95  
 
 96  
     public void close()
 97  
     {
 98  
         try
 99  
         {
 100  0
             items.add( poison );
 101  0
             thread.join();
 102  
             //noinspection ThrowableResultOfMethodCallIgnored
 103  0
             if ( pumper.getInterruptedException() != null )
 104  
             {
 105  0
                 throw pumper.getInterruptedException();
 106  
             }
 107  
         }
 108  0
         catch ( InterruptedException e )
 109  
         {
 110  0
             throw new RuntimeException( e );
 111  0
         }
 112  0
     }
 113  
 }