Coverage Report

Coverage Report - org.apache.maven.plugin.surefire.booterclient.ForkNumberBucket

Classes in this File

Line Coverage

Branch Coverage

Complexity

ForkNumberBucket

0/16

0/2

1,286

 package org.apache.maven.plugin.surefire.booterclient;
 
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * A bucket from which fork numbers can be drawn. Any drawn number needs to be returned to the bucket, in order to keep
  * the range of provided values delivered as small as possible.
  * 
  * @author Andreas Gudian
  */
 public class ForkNumberBucket
 {
 
     private static final ForkNumberBucket INSTANCE = new ForkNumberBucket();
 
     private Queue<Integer> qFree = new ConcurrentLinkedQueue<Integer>();
 
     private AtomicInteger highWaterMark = new AtomicInteger( 1 );
 
     /**
      * Non-public constructor
      */
     protected ForkNumberBucket()
     {
     }
 
     /**
      * @return a fork number that is not currently in use. The value must be returned to the bucket using
      *         {@link #returnNumber(int)}.
      */
     public static int drawNumber()
     {
         return getInstance()._drawNumber();
     }
 
     /**
      * @param number the number to return to the bucket so that it can be reused.
      */
     public static void returnNumber( int number )
     {
         getInstance()._returnNumber( number );
     }
 
     /**
      * @return a singleton instance
      */
     private static ForkNumberBucket getInstance()
     {
         return INSTANCE;
     }
 
     /**
      * @return a fork number that is not currently in use. The value must be returned to the bucket using
      *         {@link #returnNumber(int)}.
      */
     protected int _drawNumber()
     {
         Integer nextFree = qFree.poll();
 
         if ( null == nextFree )
         {
             return highWaterMark.getAndIncrement();
         }
         else
         {
             return nextFree.intValue();
         }
     }
 
     /**
      * @return the highest number that has been drawn
      */
     protected int getHighestDrawnNumber()
     {
         return highWaterMark.get() - 1;
     }
 
     /**
      * @param number the number to return to the bucket so that it can be reused.
      */
     protected void _returnNumber( int number )
     {
         qFree.add( Integer.valueOf( number ) );
     }
 }

1		package org.apache.maven.plugin.surefire.booterclient;
2
3		import java.util.Queue;
4		import java.util.concurrent.ConcurrentLinkedQueue;
5		import java.util.concurrent.atomic.AtomicInteger;
6
7		/**
8		* A bucket from which fork numbers can be drawn. Any drawn number needs to be returned to the bucket, in order to keep
9		* the range of provided values delivered as small as possible.
10		*
11		* @author Andreas Gudian
12		*/
13		public class ForkNumberBucket
14		{
15
16	0	private static final ForkNumberBucket INSTANCE = new ForkNumberBucket();
17
18	0	private Queue<Integer> qFree = new ConcurrentLinkedQueue<Integer>();
19
20	0	private AtomicInteger highWaterMark = new AtomicInteger( 1 );
21
22		/**
23		* Non-public constructor
24		*/
25		protected ForkNumberBucket()
26	0	{
27	0	}
28
29		/**
30		* @return a fork number that is not currently in use. The value must be returned to the bucket using
31		* {@link #returnNumber(int)}.
32		*/
33		public static int drawNumber()
34		{
35	0	return getInstance()._drawNumber();
36		}
37
38		/**
39		* @param number the number to return to the bucket so that it can be reused.
40		*/
41		public static void returnNumber( int number )
42		{
43	0	getInstance()._returnNumber( number );
44	0	}
45
46		/**
47		* @return a singleton instance
48		*/
49		private static ForkNumberBucket getInstance()
50		{
51	0	return INSTANCE;
52		}
53
54		/**
55		* @return a fork number that is not currently in use. The value must be returned to the bucket using
56		* {@link #returnNumber(int)}.
57		*/
58		protected int _drawNumber()
59		{
60	0	Integer nextFree = qFree.poll();
61
62	0	if ( null == nextFree )
63		{
64	0	return highWaterMark.getAndIncrement();
65		}
66		else
67		{
68	0	return nextFree.intValue();
69		}
70		}
71
72		/**
73		* @return the highest number that has been drawn
74		*/
75		protected int getHighestDrawnNumber()
76		{
77	0	return highWaterMark.get() - 1;
78		}
79
80		/**
81		* @param number the number to return to the bucket so that it can be reused.
82		*/
83		protected void _returnNumber( int number )
84		{
85	0	qFree.add( Integer.valueOf( number ) );
86	0	}
87		}