int test_main( int, char* [] )
{
try
{
sc::fifo_scheduler<> scheduler;
const sc::fifo_scheduler<>::processor_handle processor0 =
scheduler.create_processor< FifoSchedulerTest >();
Check( scheduler, processor0, 0 );
const sc::fifo_scheduler<>::processor_handle processor1 =
scheduler.create_processor< FifoSchedulerTest >( 1 );
Check( scheduler, processor1, 1 );
const sc::fifo_scheduler<>::processor_handle processor2 =
scheduler.create_processor< FifoSchedulerTest >( 1, 2 );
Check( scheduler, processor2, 12 );
const sc::fifo_scheduler<>::processor_handle processor3 =
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3 );
Check( scheduler, processor3, 123 );
const sc::fifo_scheduler<>::processor_handle processor4 =
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4 );
Check( scheduler, processor4, 1234 );
const sc::fifo_scheduler<>::processor_handle processor5 =
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5 );
Check( scheduler, processor5, 12345 );
const sc::fifo_scheduler<>::processor_handle processor6 =
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5, 6 );
Check( scheduler, processor6, 123456 );
RunScheduler( scheduler, 0UL );
bool workItem1Processed = false;
scheduler.queue_work_item(
boost::bind( &SetToTrue, boost::ref( workItem1Processed ) ) );
RunScheduler( scheduler, 1UL );
BOOST_REQUIRE( workItem1Processed );
scheduler.terminate();
RunScheduler( scheduler, 1UL );
BOOST_REQUIRE( scheduler.terminated() );
RunScheduler( scheduler, 0UL );
bool workItem2Processed = false;
scheduler.queue_work_item(
boost::bind( &SetToTrue, boost::ref( workItem2Processed ) ) );
// After being terminated, a call to operator() must not process any more
// events
RunScheduler( scheduler, 0UL );
BOOST_REQUIRE( !workItem2Processed );
}
catch ( const UnexpectedEventCount & )
{
BOOST_FAIL( "Unexpected event count." );
}
return 0;
}
void main(int argc, char* argv[])
{
int TcNum;
thread_t tid1,tid2,tid3,tid4;
if(argc != 2)
{
perror("Input TestCase Number!");
exit(0);
}
Init( );
TcNum = atoi(argv[1]);
switch(TcNum)
{
case 1:
thread_create(&tid1, NULL, (void*)TestCase1, 0);
break;
case 2:
thread_create(&tid2, NULL, (void*)TestCase2, 0);
break;
case 3:
thread_create(&tid3, NULL, (void*)TestCase3, 0);
break;
case 4:
thread_create(&tid4, NULL, (void*)TestCase4, 0);
break;
}
RunScheduler();
while(1){}
}
void Check(
sc::fifo_scheduler<> & scheduler,
const sc::fifo_scheduler<>::processor_handle & processor,
int ctorArgs )
{
refArg1 = 6;
refArg2 = 5;
refArg3 = 4;
refArg4 = 3;
refArg5 = 2;
refArg6 = 1;
// Make sure the processor has been created
RunScheduler( scheduler, 1UL );
refArg1 = refArg2 = refArg3 = refArg4 = refArg5 = refArg6 = 0;
scheduler.initiate_processor( processor );
// This event triggers the queueing of another event, which itself
// terminates the machine ...
scheduler.queue_event(
processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );
// ... that's why 3 instead of two events must have been processed
RunScheduler( scheduler, 3UL );
// Since the machine has been terminated, this event will be ignored
scheduler.queue_event( processor, MakeEvent( new EvFail() ) );
RunScheduler( scheduler, 1UL );
// Check that we can reinitiate the machine
scheduler.initiate_processor( processor );
scheduler.queue_event(
processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );
RunScheduler( scheduler, 3UL );
// Check that we are terminated again
scheduler.queue_event( processor, MakeEvent( new EvFail() ) );
RunScheduler( scheduler, 1UL );
scheduler.destroy_processor( processor );
// The following will simply be ignored because the processor has already
// be destroyed
scheduler.initiate_processor( processor );
scheduler.queue_event(
processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );
RunScheduler( scheduler, 3UL );
}
int test_main( int, char* [] )
{
try
{
sc::fifo_scheduler<> scheduler;
Check( scheduler, scheduler.create_processor< FifoSchedulerTest >(), 0 );
Check(
scheduler, scheduler.create_processor< FifoSchedulerTest >( 1 ), 1 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ) ),
6 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >( 1, 2 ),
12 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ), boost::cref( refArg2 ) ),
65 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3 ),
123 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ), boost::cref( refArg2 ),
boost::cref( refArg3 ) ),
654 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4 ),
1234 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ), boost::cref( refArg2 ),
boost::cref( refArg3 ), boost::cref( refArg4 ) ),
6543 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5 ),
12345 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ), boost::cref( refArg2 ),
boost::cref( refArg3 ), boost::cref( refArg4 ),
boost::cref( refArg5 ) ),
65432 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5, 6 ),
123456 );
Check(
scheduler,
scheduler.create_processor< FifoSchedulerTest >(
boost::cref( refArg1 ), boost::cref( refArg2 ),
boost::cref( refArg3 ), boost::cref( refArg4 ),
boost::cref( refArg5 ), boost::cref( refArg6 ) ),
654321 );
RunScheduler( scheduler, 0UL );
bool workItem1Processed = false;
scheduler.queue_work_item(
boost::bind( &SetToTrue, boost::ref( workItem1Processed ) ) );
RunScheduler( scheduler, 1UL );
BOOST_REQUIRE( workItem1Processed );
scheduler.terminate();
RunScheduler( scheduler, 1UL );
BOOST_REQUIRE( scheduler.terminated() );
RunScheduler( scheduler, 0UL );
bool workItem2Processed = false;
scheduler.queue_work_item(
boost::bind( &SetToTrue, boost::ref( workItem2Processed ) ) );
// After being terminated, a call to operator() must not process any more
// events
RunScheduler( scheduler, 0UL );
BOOST_REQUIRE( !workItem2Processed );
}
catch ( const UnexpectedEventCount & )
{
BOOST_FAIL( "Unexpected event count." );
}
return 0;
}
