/*
* Licensed 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.
*/
package net.sourceforge.basher.impl;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import net.sourceforge.basher.BasherContext;
import net.sourceforge.basher.BasherTestCase;
import net.sourceforge.basher.ContextManager;
import net.sourceforge.basher.Phase;
import net.sourceforge.basher.events.*;
import net.sourceforge.basher.internal.TaskRunner;
import org.apache.commons.logging.Log;
import org.easymock.Capture;
import static org.easymock.EasyMock.*;
/**
* @author Johan Lindquist
* @version 1.0
*/
public class TestSchedulerImpl extends BasherTestCase
{
private Log _log;
private ContextManager _contextManager;
private EventManager _eventManager;
private SchedulerImpl _schedulerImpl;
public BasherContext _basherContext;
private TaskRunner _taskRunner;
private ScheduledExecutorService _scheduledExecutorService;
public void testOneThread()
{
initializeSchedulerImpl( 1, 10 );
callGetActiveBasherContext( 1 );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
}
public void testAddOneThread()
{
initializeSchedulerImpl( 1, 10 );
callGetActiveBasherContext( 2 );
initializeLoggingForStart( 1 );
_log.debug( "Adding new thread" );
_log.info( "Thread added. 2 thread(s) running" );
_taskRunner.run();
_eventManager.publish( isA( ThreadAddedEvent.class ) );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
_schedulerImpl.addThread();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 2, numThreads );
}
public void testAddOneThreadAndStop()
{
initializeSchedulerImpl( 1, 10 );
callGetActiveBasherContext( 2 );
initializeLoggingForStart( 1 );
_log.debug( "Adding new thread" );
_log.info( "Thread added. 2 thread(s) running" );
initLoggingForStop( 2 );
_taskRunner.run();
_eventManager.publish( isA( ThreadAddedEvent.class ) );
_eventManager.publish( new PhaseTransitionEvent( _basherContext, Phase.RUN, Phase.END, 0 ) );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
_schedulerImpl.addThread();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 2, numThreads );
sleep( 200 );
_schedulerImpl.stop();
}
public void testStop()
{
initializeSchedulerImpl( 0, 10 );
initializeLoggingForStart( 1 );
initLoggingForStop( 0 );
expect( _contextManager.getActiveBasherContext() ).andReturn( _basherContext );
_eventManager.publish( new PhaseTransitionEvent( _basherContext, Phase.RUN, Phase.END, 0 ) );
replayAll();
_schedulerImpl.start();
sleep( 100 );
final int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
_schedulerImpl.stop();
assertFalse( "Running when not supposed to", _schedulerImpl.isRunning() );
}
public void testStart()
{
initializeSchedulerImpl( 0, 10 );
_log.info( "Starting scheduler with context: default" );
_log.info( "Scheduler started. 0 thread(s) running" );
replayAll();
_schedulerImpl.start();
final int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
assertTrue( "Not running", _schedulerImpl.isRunning() );
try
{
_schedulerImpl.start();
fail( "Could start again" );
}
catch ( IllegalStateException e )
{
assertEquals( "Already started", e.getMessage() );
}
verifyAllMockControls();
}
public void testStartNullParams()
{
initializeSchedulerImpl( 0, 0 );
replayAll();
try
{
_schedulerImpl.start( ( String ) null );
fail( "Could start with null context name" );
}
catch ( NullPointerException e )
{
// should happen
}
try
{
_schedulerImpl.start( ( BasherContext ) null );
fail( "Could start with null context" );
}
catch ( NullPointerException e )
{
// should happen
}
}
public void testStartWithUnknownContextName()
{
initializeSchedulerImpl( 0, 0 );
try
{
_schedulerImpl.start( "notknown" );
fail( "Could start with unknown context name" );
}
catch ( IllegalArgumentException e )
{
// should happen
}
}
public void testSchedulingAtStart()
{
initializeSchedulerImpl( 0, 0 );
replayAll();
_schedulerImpl.start();
verifyAll();
}
public void testAddOneThreadWhenMaxReached()
{
initializeSchedulerImpl( 1, 1 );
callGetActiveBasherContext( 2 );
_log.warn( "Maximum thread limit (1) reached, not adding more threads" );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
_schedulerImpl.addThread();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
sleep( 100 );
verifyAll();
}
public void testAddManyThreads()
{
initializeSchedulerImpl( 1, 10 );
callGetActiveBasherContext( 2 );
_log.debug( "Adding 2 thread(s)" );
_log.debug( "Adding new thread" );
_log.info( "Thread added. 2 thread(s) running" );
_log.debug( "Adding new thread" );
_log.info( "Thread added. 3 thread(s) running" );
_log.debug( "2 thread(s) added" );
_taskRunner.run();
_taskRunner.run();
_eventManager.publish( isA( ThreadAddedEvent.class ) );
_eventManager.publish( isA( ThreadAddedEvent.class ) );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
_schedulerImpl.addThreads( 2 );
sleep( 200 );
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 3, numThreads );
verifyAll();
}
public void testRemoveThreads()
{
initializeSchedulerImpl( 1, 10 );
_log.debug( "Removing thread from active list" );
_log.debug( "Thread TaskRunner-0 removed from active list" );
_log.debug( "Signalling stop thread for thread named: TaskRunner-0" );
_log.debug( "Thread stop signalled" );
_eventManager.publish( isA( ThreadRemovedEvent.class ) );
replayAll();
_schedulerImpl.start();
sleep( 100 );
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 1, numThreads );
_schedulerImpl.removeThread();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
verifyAll();
}
public void testRemoveThreadsWhenNoneToRemove()
{
initializeSchedulerImpl( 0, 10 );
_log.warn( "No threads to remove" );
replayAll();
_schedulerImpl.start();
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
_schedulerImpl.removeThread();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
verifyAll();
}
public void testInitialization()
{
_schedulerImpl = new SchedulerImpl();
try
{
_schedulerImpl.start();
fail( "Passed log check" );
}
catch ( IllegalStateException e )
{
assertEquals( "no log", e.getMessage() );
}
_schedulerImpl = new SchedulerImpl();
_log = createMock( Log.class );
_schedulerImpl.setLog( _log );
try
{
_schedulerImpl.start();
fail( "Passed context manager check" );
}
catch ( IllegalStateException e )
{
assertEquals( "no context manager", e.getMessage() );
}
_contextManager = createMock( ContextManager.class );
_schedulerImpl.setContextManager( _contextManager );
try
{
_schedulerImpl.start();
fail( "Passed event manager check" );
}
catch ( IllegalStateException e )
{
assertEquals( "no event manager", e.getMessage() );
}
_eventManager = createMock( EventManager.class );
_schedulerImpl.setEventManager( _eventManager );
try
{
_schedulerImpl.start();
fail( "Passed task runner check" );
}
catch ( IllegalStateException e )
{
assertEquals( "no task runner", e.getMessage() );
}
_schedulerImpl = new SchedulerImpl();
final String message = "Not started";
try
{
_schedulerImpl.addThread();
fail( "Passed add thread" );
}
catch ( IllegalStateException e )
{
assertEquals( message, e.getMessage() );
}
try
{
_schedulerImpl.addThreads( 5 );
fail( "Passed add n threads" );
}
catch ( IllegalStateException e )
{
assertEquals( message, e.getMessage() );
}
try
{
_schedulerImpl.getNumberOfActiveThreads();
}
catch ( IllegalStateException e )
{
assertEquals( message, e.getMessage() );
}
try
{
_schedulerImpl.removeAllThreads();
}
catch ( IllegalStateException e )
{
assertEquals( message, e.getMessage() );
}
try
{
_schedulerImpl.removeThread();
}
catch ( IllegalStateException e )
{
assertEquals( message, e.getMessage() );
}
try
{
_schedulerImpl.stop();
}
catch ( IllegalStateException e )
{
assertEquals( "Already stopped", e.getMessage() );
}
// verifyAll();
}
public void testRemoveAllThreads()
{
initializeSchedulerImpl( 2, 10 );
_log.debug( "Removing 2 thread(s)" );
_log.debug( "Removing thread from active list" );
_log.debug( "Removing thread from active list" );
_log.debug( "Thread TaskRunner-0 removed from active list" );
_log.debug( "Thread TaskRunner-1 removed from active list" );
_log.debug( "Signalling stop thread for thread named: TaskRunner-0" );
_log.debug( "Signalling stop thread for thread named: TaskRunner-1" );
_log.debug( "Thread stop signalled" );
_log.debug( "Thread stop signalled" );
_log.debug( "2 thread(s) removed" );
_eventManager.publish( isA( ThreadRemovedEvent.class ) );
_eventManager.publish( isA( ThreadRemovedEvent.class ) );
replayAll();
_schedulerImpl.start();
sleep( 100 );
int numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 2, numThreads );
_schedulerImpl.removeAllThreads();
numThreads = _schedulerImpl.getNumberOfActiveThreads();
assertEquals( "Invalid number of threads", 0, numThreads );
verifyAll();
}
public void testEnteringSetupPhase()
{
try
{
_log.info( "Received phase transition: START -> SETUP [SETUP duration 0 second(s)]" );
_log.debug( "Scheduling phase transition SETUP -> WARMUP at 1000" );
final Capture<EventEmitterTimerTask> capture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.schedule( capture( capture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.START, Phase.SETUP, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = capture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.SETUP, Phase.WARMUP );
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
private void validatePhaseTransitionEvent( final EventEmitterTimerTask eventEmitterTimerTask, final Phase oldPhase, final Phase newPhase )
{
final BasherEvent basherEvent = eventEmitterTimerTask.getBasherEvent();
assertNotNull( "no event", basherEvent );
assertTrue( "bad event type", basherEvent instanceof PhaseTransitionEvent );
PhaseTransitionEvent phaseTransitionEvent = ( PhaseTransitionEvent ) basherEvent;
assertEquals( "bad old phase", oldPhase, phaseTransitionEvent.getOldPhase() );
assertEquals( "bad new phase", newPhase, phaseTransitionEvent.getNewPhase() );
}
public void testEnteringWarmupPhase()
{
try
{
_log.info( "Received phase transition: SETUP -> WARMUP [WARMUP duration 0 second(s)]" );
_log.debug( "Scheduling phase transition WARMUP -> RUN at 1" );
final Capture<EventEmitterTimerTask> capture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.schedule( capture( capture ), eq( 1L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.SETUP, Phase.WARMUP, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = capture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.WARMUP, Phase.RUN );
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
public void testEnteringRunPhase()
{
try
{
_log.info( "Received phase transition: WARMUP -> RUN [RUN duration 0 second(s)]" );
_log.debug( "Scheduling phase transition RUN -> COOLDOWN at 1" );
final Capture<EventEmitterTimerTask> phaseTransitionEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStartEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStopEventEmitterCapture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( phaseTransitionEventEmitterCapture ), eq( 1L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStartEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStopEventEmitterCapture ), eq( 3000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.WARMUP, Phase.RUN, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = phaseTransitionEventEmitterCapture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.RUN, Phase.COOLDOWN);
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
public void testEnteringRunPhaseWithThreadIncrementation()
{
try
{
_basherContext.setThreadIncrementCount( 1 );
_basherContext.setThreadIncrementInterval( 10 );
_log.info( "Received phase transition: WARMUP -> RUN [RUN duration 0 second(s)]" );
_log.debug( "Scheduling phase transition RUN -> COOLDOWN at 1" );
final Capture<EventEmitterTimerTask> phaseTransitionEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStartEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStopEventEmitterCapture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( phaseTransitionEventEmitterCapture ), eq( 1L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStartEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStopEventEmitterCapture ), eq( 3000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.WARMUP, Phase.RUN, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = phaseTransitionEventEmitterCapture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.RUN, Phase.COOLDOWN);
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
/*
public void testEnteringCooldownPhase()
{
try
{
_log.info( "Received phase transition: RUN -> COOLDOWN [COOLDOWN duration 0 second(s)]" );
_log.debug( "Scheduling phase transition COOLDOWN -> TEARDOWN at 1" );
final Capture<EventEmitterTimerTask> phaseTransitionEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStartEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStopEventEmitterCapture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( phaseTransitionEventEmitterCapture ), eq( 1L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStartEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStopEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.RUN, Phase.COOLDOWN, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = phaseTransitionEventEmitterCapture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.RUN, Phase.COOLDOWN);
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
public void testEnteringCooldownWithThreadIncrementation()
{
try
{
_basherContext.setThreadIncrementCount( 1 );
_basherContext.setThreadIncrementInterval( 10 );
_log.info( "Received phase transition: WARMUP -> RUN [RUN duration 0 second(s)]" );
_log.debug( "Scheduling phase transition RUN -> COOLDOWN at 1" );
final Capture<EventEmitterTimerTask> phaseTransitionEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStartEventEmitterCapture = new Capture<EventEmitterTimerTask>();
final Capture<EventEmitterTimerTask> collectionStopEventEmitterCapture = new Capture<EventEmitterTimerTask>();
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.scheduleAtFixedRate( eq((Runnable)null),eq(10000L),eq(10000L),eq(TimeUnit.MILLISECONDS) )).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( phaseTransitionEventEmitterCapture ), eq( 1L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStartEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
expect( _scheduledExecutorService.schedule( capture( collectionStopEventEmitterCapture ), eq( 1000L ), eq( TimeUnit.MILLISECONDS ) ) ).andReturn( createMock( ScheduledFuture.class ) );
replayAll();
_schedulerImpl.basherEvent( new PhaseTransitionEvent( _basherContext, Phase.WARMUP, Phase.RUN, 0 ) );
final EventEmitterTimerTask eventEmitterTimerTask = phaseTransitionEventEmitterCapture.getValue();
assertNotNull( "no task", eventEmitterTimerTask );
validatePhaseTransitionEvent( eventEmitterTimerTask, Phase.RUN, Phase.COOLDOWN);
}
catch ( Exception e )
{
e.printStackTrace();
}
verifyAll();
}
*/
private void initLoggingForStop( final int count )
{
_log.info( "Stopping scheduler" );
for ( int i = 0; i < count; i++ )
{
_log.debug( "Stopping task runner name" );
}
_log.info( "Scheduler stopped" );
}
private void initializeLoggingForStart( final int count )
{
_log.info( "Starting scheduler with context: default" );
for ( int i = 0; i < count; i++ )
{
_log.debug( "Adding new thread" );
_log.info( "Thread added. " + ( i + 1 ) + " thread(s) running" );
}
_log.info( "Scheduler started. " + count + " thread(s) running" );
}
private void initializeSchedulerImpl( final int initialNumberThreads, final int maxThreads )
{
initializeLoggingForStart( initialNumberThreads );
_basherContext.setInitialNumberThreads( initialNumberThreads );
_basherContext.setMaxNumberThreads( maxThreads );
_contextManager.setActiveBasherContext( _basherContext );
expect( _contextManager.getBasherContext( "default" ) ).andReturn( _basherContext );
_log.info( "Basher Context Details:" );
_log.info("Identifier: not-null");
_log.info( "BeanShell Directory: src/test/basher-scripts" );
_log.info( "Run Duration: " + 0 );
_log.info( "Initial Number of Threads: " + initialNumberThreads );
_log.info( "Average Interval: " + 10 );
_eventManager.publish( new PhaseTransitionEvent( _basherContext, null, Phase.START, 0 ) );
_eventManager.publish( new PhaseTransitionEvent( _basherContext, Phase.START, Phase.SETUP, 0 ) );
for ( int i = 0; i < initialNumberThreads; i++ )
{
_eventManager.publish( isA( ThreadAddedEvent.class ) );
_taskRunner.run();
}
}
private void callGetActiveBasherContext( final int numInvocations )
{
for ( int i = 0; i < numInvocations; i++ )
{
expect( _contextManager.getActiveBasherContext() ).andReturn( _basherContext );
}
}
@Override
protected void setUp() throws Exception
{
super.setUp();
_basherContext = new BasherContext();
_basherContext.setName( "default" );
_basherContext.setRunIdentifier( "not-null" );
_basherContext.setInitialNumberThreads( 5 );
_basherContext.setMaxNumberThreads( 10 );
_basherContext.setSetupDuration( 0 );
_basherContext.setCooldownDuration( 0 );
_basherContext.setWarmupDuration( 0 );
_basherContext.setTeardownDuration( 0 );
_basherContext.setStartCollectionFrom(1);
_basherContext.setStopCollectionAfter(3);
_log = createMock( Log.class );
_schedulerImpl = new SchedulerImpl();
_schedulerImpl.setLog( _log );
_contextManager = createMock( ContextManager.class );
_eventManager = createMock( EventManager.class );
makeThreadSafe( _eventManager, true );
_taskRunner = createMock( TaskRunner.class );
makeThreadSafe( _taskRunner, true );
_scheduledExecutorService = createMock( ScheduledExecutorService.class );
_schedulerImpl.setScheduledExecutorService( _scheduledExecutorService );
_schedulerImpl.setEventManager( _eventManager );
_schedulerImpl.setContextManager( _contextManager );
_schedulerImpl.setTaskRunner( _taskRunner );
}
}
|