rtt: rtt: taskthread_test.cpp Source File

00001 /***************************************************************************
00002   tag: Peter Soetens  Tue Apr 5 16:53:26 CEST 2005  taskthread_test.cpp
00003 
00004                         taskthread_test.cpp -  description
00005                            -------------------
00006     begin                : Tue April 05 2005
00007     copyright            : (C) 2005 Peter Soetens
00008     email                : peter.soetens@mech.kuleuven.ac.be
00009 
00010  ***************************************************************************
00011  *                                                                         *
00012  *   This program is free software; you can redistribute it and/or modify  *
00013  *   it under the terms of the GNU General Public License as published by  *
00014  *   the Free Software Foundation; either version 2 of the License, or     *
00015  *   (at your option) any later version.                                   *
00016  *                                                                         *
00017  ***************************************************************************/
00018 
00019 
00020 #include "unit.hpp"
00021 
00022 #include "taskthread_test.hpp"
00023 
00024 #include <iostream>
00025 
00026 #include <extras/Activities.hpp>
00027 #include <extras/TimerThread.hpp>
00028 #include <extras/SimulationThread.hpp>
00029 #include <os/MainThread.hpp>
00030 #include <Logger.hpp>
00031 #include <rtt-config.h>
00032 
00033 using namespace std;
00034 using namespace RTT;
00035 
00036 struct A {};
00037 
00038 template<class T>
00039 struct TestActivity
00040     : public T
00041 {
00042     bool result, _dothrow;
00043     bool init, stepped, fini;
00044     bool wasrunning, wasactive;
00045 
00046     ActivityInterface* owner;
00047 
00048     TestActivity(int prio, double per, bool fail, bool dothrow = false)
00049         :T(prio,per), _dothrow(dothrow)
00050     {
00051         this->reset(fail);
00052     }
00053 
00054     bool initialize() {
00055         init    = true;
00056         return result;
00057     }
00058     void step() {
00059         stepped = true;
00060         wasrunning = this->isRunning();
00061         wasactive = this->isActive();
00062 #ifndef ORO_EMBEDDED
00063         if ( _dothrow )
00064             throw A();
00065 #endif
00066     }
00067     void finalize() {
00068         fini   = true;
00069     }
00070 
00071     void reset(bool fail) {
00072         result = fail;
00073         init = false;
00074         stepped = false;
00075         fini = false;
00076         wasrunning=false;
00077         wasactive=false;
00078     }
00079 };
00080 
00081 struct TestRunner
00082     : public RunnableInterface
00083 {
00084     bool result;
00085     bool init, stepped, fini;
00086     bool looped, broke;
00087     bool wasrunning, wasactive;
00088 
00089     TestRunner(bool fail)
00090     {
00091         this->reset(fail);
00092     }
00093 
00094     bool initialize() {
00095         init    = true;
00096         BOOST_CHECK(getActivity()->isActive());
00097         BOOST_CHECK(!getActivity()->isRunning());
00098         return result;
00099     }
00100     void step() {
00101         stepped = true;
00102         wasrunning=getActivity()->isRunning();
00103         wasactive=getActivity()->isActive();
00104     }
00105 
00106     void loop() {
00107         looped = true;
00108         wasrunning=getActivity()->isRunning();
00109         wasactive=getActivity()->isActive();
00110     }
00111 
00112     bool breakLoop() {
00113         broke = true;
00114         return true;
00115     }
00116 
00117     void finalize() {
00118         fini   = true;
00119         BOOST_CHECK(getActivity()->isActive());
00120         BOOST_CHECK(!getActivity()->isRunning());
00121     }
00122 
00123     void reset(bool fail) {
00124         result = fail;
00125         init = false;
00126         stepped = false;
00127         fini = false;
00128         looped = false;
00129         broke = false;
00130         wasrunning = false;
00131         wasactive = false;
00132     }
00133 };
00134 
00135 
00136 void
00137 ActivitiesThreadTest::setUp()
00138 {
00139     t_task_np = new TestActivity<PeriodicActivity>(3, 0.01, true );           // will be stopped if np_bad throws
00140     t_task_np_bad = new TestActivity<PeriodicActivity>(3, 0.01, true, true ); // throws
00141     t_task_p = new TestActivity<PeriodicActivity>(3, 0.032, true );           // does not throw
00142     t_task_a = new TestActivity<Activity>(3, 0.01, true, true );              // throws
00143 }
00144 
00145 
00146 void
00147 ActivitiesThreadTest::tearDown()
00148 {
00149     delete t_task_np;
00150     delete t_task_np_bad;
00151     delete t_task_p;
00152     delete t_task_a;
00153 }
00154 
00155 // Registers the fixture into the 'registry'
00156 BOOST_FIXTURE_TEST_SUITE( ActivitiesThreadTestSuite, ActivitiesThreadTest )
00157 
00158 BOOST_AUTO_TEST_CASE(testPeriodic )
00159 {
00160     // Test periodic task sequencing...
00161 
00162     PeriodicActivity mtask( 15, 0.01 );
00163     BOOST_CHECK( mtask.isActive() == false );
00164     BOOST_CHECK( mtask.isRunning() == false );
00165     BOOST_CHECK( mtask.thread()->isRunning() == false );
00166     BOOST_CHECK_EQUAL( 0.01, mtask.thread()->getPeriod() );
00167 
00168     // Adapt priority levels to OS.
00169     int bprio = 15, rtsched = ORO_SCHED_RT;
00170     os::CheckPriority( rtsched, bprio );
00171 
00172     BOOST_CHECK_EQUAL( bprio, mtask.thread()->getPriority() );
00173     BOOST_CHECK_EQUAL( rtsched, mtask.thread()->getScheduler() );
00174 
00175     PeriodicActivity m2task( 15, 0.01 );
00176     BOOST_CHECK( mtask.thread() == m2task.thread() );
00177 
00178     // starting...
00179     BOOST_CHECK( mtask.start() == true );
00180     BOOST_CHECK( mtask.isRunning() == true );
00181     BOOST_CHECK( mtask.thread()->isRunning() == true );
00182     BOOST_CHECK( m2task.isRunning() == false );
00183     BOOST_CHECK( m2task.start() == true );
00184     BOOST_CHECK( m2task.isRunning() == true );
00185 
00186     usleep(100000);
00187 
00188     // stopping...
00189     BOOST_CHECK( mtask.stop() == true );
00190     BOOST_CHECK( mtask.isRunning() == false );
00191     BOOST_CHECK( m2task.isRunning() == true );
00192     BOOST_CHECK( m2task.stop() == true );
00193     BOOST_CHECK( m2task.isRunning() == false );
00194 
00195     // Different Scheduler (don't test if invalid priorities)
00196     bprio = 15;
00197     rtsched = ORO_SCHED_RT;
00198     if ( os::CheckPriority( rtsched, bprio ) ) {
00199         PeriodicActivity m3task(ORO_SCHED_OTHER, 15, 0.01);
00200         bprio = 15;
00201         rtsched = ORO_SCHED_OTHER;
00202         if ( os::CheckPriority( rtsched, bprio ) ) {
00203             BOOST_CHECK( mtask.thread() != m3task.thread() );
00204             BOOST_CHECK_EQUAL( ORO_SCHED_OTHER, m3task.thread()->getScheduler() );
00205         }
00206     }
00207 
00208     // Starting thread if thread not running
00209     BOOST_CHECK( mtask.thread()->stop() );
00210     BOOST_CHECK( mtask.thread()->isRunning() == false );
00211     BOOST_CHECK( mtask.start() );
00212     BOOST_CHECK( mtask.isRunning() == true );
00213     BOOST_CHECK( mtask.thread()->isRunning() == true);
00214 }
00215 
00216 BOOST_AUTO_TEST_CASE( testNonPeriodic )
00217 {
00218     // Test periodic task sequencing...
00219 
00220     Activity mtask( 15 );
00221     usleep(100000);
00222     // Adapt priority levels to OS.
00223     int bprio = 15, rtsched = ORO_SCHED_RT;
00224     os::CheckPriority( rtsched, bprio );
00225 
00226     BOOST_CHECK( mtask.isActive() == false );
00227     BOOST_CHECK( mtask.isRunning() == false );
00228     BOOST_CHECK( mtask.thread()->isRunning() == false );
00229     BOOST_CHECK_EQUAL( bprio, mtask.thread()->getPriority() );
00230     BOOST_CHECK_EQUAL( rtsched, mtask.thread()->getScheduler() );
00231 
00232     Activity m2task( 15 );
00233     BOOST_CHECK( mtask.thread() != m2task.thread() );
00234 
00235     // starting...
00236     BOOST_CHECK( mtask.start() == true );
00237     BOOST_CHECK( mtask.isActive() == true );
00238     BOOST_CHECK( m2task.isActive() == false );
00239     BOOST_CHECK( m2task.start() == true );
00240     BOOST_CHECK( m2task.isActive() == true );
00241 
00242     usleep(100000);
00243 
00244     // stopping...
00245     BOOST_CHECK( mtask.stop() == true );
00246     BOOST_CHECK( mtask.isActive() == false );
00247     BOOST_CHECK( m2task.isActive() == true );
00248     BOOST_CHECK( m2task.stop() == true );
00249     BOOST_CHECK( m2task.isActive() == false );
00250 
00251     // Different Scheduler
00252     bprio = 15;
00253     rtsched = ORO_SCHED_OTHER;
00254     if ( os::CheckPriority( rtsched, bprio ) ) {
00255         Activity m3task(ORO_SCHED_OTHER, 15, 0.0);
00256         BOOST_CHECK( mtask.thread() != m3task.thread() );
00257         BOOST_CHECK_EQUAL( ORO_SCHED_OTHER, m3task.thread()->getScheduler() );
00258     }
00259 }
00260 
00261 BOOST_AUTO_TEST_CASE( testSlave )
00262 {
00263     // Test slave activities
00264     TestRunner r(true);
00265 
00266     // without master, NP.
00267     SlaveActivity mtask(&r);
00268     BOOST_CHECK( mtask.isActive() == false );
00269     BOOST_CHECK( mtask.isRunning() == false );
00270     BOOST_CHECK( mtask.isPeriodic() == false );
00271     BOOST_CHECK( mtask.getPeriod() == 0.0 );
00272     BOOST_CHECK( mtask.execute() == false );
00273     BOOST_CHECK( mtask.thread() == os::MainThread::Instance() );
00274 
00275     // starting...
00276     BOOST_CHECK( mtask.start() == true );
00277     BOOST_CHECK( r.init == true );
00278 
00279     BOOST_CHECK( mtask.isActive() == true );
00280     BOOST_CHECK( mtask.isRunning() == false );
00281     BOOST_CHECK( mtask.start() == false );
00282 
00283     // calls loop()
00284     BOOST_CHECK( mtask.execute() );
00285     BOOST_CHECK( r.looped == true );
00286     BOOST_CHECK( mtask.execute() );
00287     BOOST_CHECK( r.wasrunning );
00288     BOOST_CHECK( r.wasactive );
00289 
00290     // stopping...
00291     BOOST_CHECK( mtask.stop() == true );
00292     BOOST_CHECK( r.fini == true );
00293     BOOST_CHECK( mtask.isRunning() == false );
00294     BOOST_CHECK( mtask.isActive() == false );
00295     BOOST_CHECK( mtask.stop() == false );
00296 
00297     BOOST_CHECK( mtask.execute() == false );
00298 
00299     r.reset(true);
00300 
00301     // with periodic master:
00302     SlaveActivity mslave( t_task_np, &r );
00303     BOOST_CHECK( mslave.isActive() == false );
00304     BOOST_CHECK( mslave.isRunning() == false );
00305     BOOST_CHECK( mslave.isPeriodic() == true );
00306     BOOST_CHECK_EQUAL( mslave.getPeriod(), t_task_np->getPeriod() );
00307     BOOST_CHECK( mslave.execute() == false );
00308     BOOST_CHECK( mslave.thread() == t_task_np->thread() );
00309 
00310     BOOST_CHECK( !mslave.start() );
00311     BOOST_CHECK( t_task_np->start() );
00312     BOOST_CHECK( mslave.start() );
00313     BOOST_CHECK( r.init == true );
00314     BOOST_CHECK( mslave.isActive() );
00315     BOOST_CHECK( mslave.isRunning() );
00316 
00317     // calls step()
00318     BOOST_CHECK( mslave.execute() );
00319     BOOST_CHECK( r.stepped == true );
00320     BOOST_CHECK( r.wasrunning );
00321     BOOST_CHECK( r.wasactive );
00322     BOOST_CHECK( mslave.execute() );
00323     BOOST_CHECK( !mslave.start() );
00324 
00325     // stopping...
00326     BOOST_CHECK( mslave.stop() );
00327     BOOST_CHECK( r.fini == true );
00328     BOOST_CHECK( !mslave.isActive() );
00329     BOOST_CHECK( !mslave.isRunning() );
00330 
00331     r.reset(true);
00332 
00333     // periodic:
00334     SlaveActivity mslave_p(0.001, &r);
00335     BOOST_CHECK( mslave_p.isActive() == false );
00336     BOOST_CHECK( mslave_p.isRunning() == false );
00337     BOOST_CHECK( mslave_p.isPeriodic() == true );
00338     BOOST_CHECK( mslave_p.getPeriod() == 0.001 );
00339     BOOST_CHECK( mslave_p.execute() == false );
00340     BOOST_CHECK( mslave_p.thread() == os::MainThread::Instance() );
00341 
00342     BOOST_CHECK( mslave_p.start() );
00343     BOOST_CHECK( r.init == true );
00344     BOOST_CHECK( mslave_p.isActive() );
00345     BOOST_CHECK( mslave_p.isRunning() );
00346     BOOST_CHECK( mslave_p.execute() );
00347     BOOST_CHECK( r.stepped == true );
00348     BOOST_CHECK( r.wasrunning );
00349     BOOST_CHECK( r.wasactive );
00350     BOOST_CHECK( !mslave_p.start() );
00351 
00352     // stopping...
00353     BOOST_CHECK( mslave_p.stop() );
00354     BOOST_CHECK( r.fini == true );
00355     BOOST_CHECK( !mslave_p.isActive() );
00356     BOOST_CHECK( !mslave_p.isRunning() );
00357     BOOST_CHECK( !mslave_p.execute() );
00358 }
00359 
00360 BOOST_AUTO_TEST_CASE( testSequential )
00361 {
00362     // Test sequential activities
00363     TestRunner r(true);
00364 
00365     SequentialActivity mtask(&r);
00366     BOOST_CHECK( mtask.isActive() == false );
00367     BOOST_CHECK( mtask.isRunning() == false );
00368     BOOST_CHECK( mtask.isPeriodic() == false );
00369     BOOST_CHECK( mtask.getPeriod() == 0.0 );
00370     BOOST_CHECK( mtask.execute() == false );
00371     BOOST_CHECK( mtask.trigger() == false );
00372     BOOST_CHECK( mtask.thread() == os::MainThread::Instance() );
00373 
00374     // starting...
00375     BOOST_CHECK( mtask.start() == true );
00376     BOOST_CHECK( r.init == true );
00377 
00378     BOOST_CHECK( mtask.isActive() == true );
00379     BOOST_CHECK( mtask.isRunning() == false );
00380     BOOST_CHECK( mtask.start() == false );
00381 
00382     // calls step()
00383     BOOST_CHECK( mtask.trigger() );
00384     BOOST_CHECK( r.stepped == true );
00385     BOOST_CHECK( r.wasrunning );
00386     BOOST_CHECK( r.wasactive );
00387     BOOST_CHECK( mtask.execute() == false );
00388 
00389     // stopping...
00390     BOOST_CHECK( mtask.stop() == true );
00391     BOOST_CHECK( r.fini == true );
00392     BOOST_CHECK( mtask.isRunning() == false );
00393     BOOST_CHECK( mtask.isActive() == false );
00394     BOOST_CHECK( mtask.stop() == false );
00395 
00396     BOOST_CHECK( mtask.execute() == false );
00397     BOOST_CHECK( mtask.trigger() == false );
00398 
00399     r.reset(false);
00400     BOOST_CHECK( mtask.start() == false );
00401     BOOST_CHECK( r.init == true );
00402 
00403     BOOST_CHECK( mtask.isActive() == false );
00404     BOOST_CHECK( mtask.isRunning() == false );
00405     BOOST_CHECK( mtask.start() == false );
00406 }
00407 
00408 BOOST_AUTO_TEST_CASE( testScheduler )
00409 {
00410     int rtsched = ORO_SCHED_OTHER;
00411     int bprio = 15;
00412 
00413     os::CheckPriority( rtsched, bprio );
00414     TimerThreadPtr tt = TimerThread::Instance(rtsched, bprio, 0.0123);
00415     BOOST_CHECK( tt != 0 );
00416 
00417     BOOST_CHECK( tt->isRunning() == false );
00418 
00419     BOOST_CHECK_EQUAL( 0.0123, tt->getPeriod());
00420 
00421     BOOST_CHECK_EQUAL( bprio, tt->getPriority());
00422     BOOST_CHECK_EQUAL( rtsched, tt->getScheduler());
00423 
00424     // different scheduler, different thread.
00425     rtsched = ORO_SCHED_RT;
00426     bprio = 15;
00427     if ( os::CheckPriority( rtsched, bprio ) ) {
00428         TimerThreadPtr tt2 = TimerThread::Instance(rtsched, bprio, 0.0123);
00429         BOOST_CHECK( tt2 != 0 );
00430         BOOST_CHECK( tt2 != tt );
00431         usleep(100000);
00432         BOOST_CHECK_EQUAL( rtsched, tt2->getScheduler());
00433 
00434         tt = TimerThread::Instance(bprio, 0.0123); // ORO_SCHED_RT is the default.
00435         BOOST_CHECK( tt == tt2 );
00436     }
00437 }
00438 
00442 BOOST_AUTO_TEST_CASE( testThreadPID )
00443 {
00444         unsigned int tid = t_task_a->getPid();
00445         BOOST_CHECK( tid );
00446         unsigned int mpid = MainThread::Instance()->getPid();
00447         BOOST_CHECK( mpid );
00448         BOOST_CHECK_NE( mpid, tid );
00449 //      cout << "PID:" << mpid <<endl;
00450 //      cout << "TID:" << tid << endl;
00451 }
00452 
00453 #if !defined( OROCOS_TARGET_WIN32 )
00454 BOOST_AUTO_TEST_CASE( testThreadConfig )
00455 {
00456     int rtsched = ORO_SCHED_RT;
00457     int bprio = 15;
00458     TimerThreadPtr tt = TimerThread::Instance(bprio, 0.0123);
00459 
00460     // Test creation of new thread, check functions when not running.
00461     BOOST_CHECK( tt->isRunning() == false );
00462 
00463     BOOST_CHECK_EQUAL( 0.0123, tt->getPeriod());
00464 
00465     // only do this if valid priority/scheduler range:
00466     if ( os::CheckPriority( rtsched, bprio ) == true)
00467     {
00468         BOOST_CHECK_EQUAL( bprio, tt->getPriority());
00469 
00470         // different priority, different thread.
00471         TimerThreadPtr tt2 = TimerThread::Instance(bprio - 1, 0.0123);
00472         BOOST_CHECK( tt2 != 0 );
00473         BOOST_CHECK( tt2 != tt );
00474 
00475         // different period, different thread.
00476         TimerThreadPtr tt3 = TimerThread::Instance(bprio, 0.123);
00477         BOOST_CHECK( tt3 != 0 );
00478         BOOST_CHECK( tt3 != tt );
00479         BOOST_CHECK( tt3 != tt2 );
00480     }
00481 
00482     tt = TimerThread::Instance(bprio, 0.0123);
00483     BOOST_CHECK( tt != 0 );
00484     BOOST_CHECK( tt == TimerThread::Instance(bprio,0.0123) );
00485 
00486     // switching hard/soft
00487     // do not ASSERT since the ret-value may be false...
00488     if ( tt->setScheduler(ORO_SCHED_OTHER) ) {
00489         usleep(100000);
00490         BOOST_CHECK( tt->getScheduler() == ORO_SCHED_OTHER );
00491     }
00492     if ( tt->setScheduler(ORO_SCHED_RT) ) {
00493         usleep(100000);
00494         BOOST_CHECK( tt->getScheduler() == ORO_SCHED_RT );
00495     }
00496     tt->setScheduler(ORO_SCHED_OTHER);
00497     tt->setScheduler(ORO_SCHED_RT);
00498     tt->setScheduler(ORO_SCHED_OTHER);
00499     tt->setScheduler(ORO_SCHED_RT);
00500     if ( tt->setPriority( 4 ) ) {
00501         BOOST_CHECK_EQUAL( tt->getPriority(), 4 );
00502 
00503         // even if the priority was changed after construction,
00504         // the thread can be found:
00505         BOOST_CHECK( tt == TimerThread::Instance(4,0.0123) );
00506     }
00507 
00508     BOOST_CHECK( tt->start() );
00509 
00510     // Check functions when running:
00511     BOOST_CHECK( tt->isRunning() == true );
00512 
00513     // prints annoying warning messages...
00514     Logger::LogLevel ll = Logger::log().getLogLevel();
00515     Logger::log().setLogLevel(Logger::Critical);
00516 #ifndef OROCOS_TARGET_XENOMAI // disabled until 'persistent' scheduler switching is implemented for Xenomai.
00517     if ( tt->setScheduler(ORO_SCHED_RT) ) {
00518         usleep(100000);
00519         BOOST_CHECK( tt->getScheduler() == ORO_SCHED_RT );
00520     }
00521     if ( tt->setScheduler(ORO_SCHED_OTHER) ) {
00522         usleep(100000);
00523         BOOST_CHECK( tt->getScheduler() == ORO_SCHED_OTHER );
00524     }
00525 #endif
00526     Logger::log().setLogLevel( ll );
00527 
00528     // reconfigure periodicity when running.
00529     BOOST_CHECK( tt->setPeriod(0.5) == true );
00530 
00531     // reconfigure periodicity when stopped.
00532     BOOST_CHECK( tt->stop() );
00533     BOOST_CHECK( tt->setPeriod(0.3) );
00534     BOOST_CHECK_EQUAL( Seconds_to_nsecs(0.3), tt->getPeriodNS() );
00535 
00536     // some quick start/stops.
00537     BOOST_CHECK( tt->start() );
00538     BOOST_CHECK( tt->stop() );
00539     BOOST_CHECK( tt->start() );
00540 
00541 }
00542 #endif
00543 
00544 #if !defined( ORO_EMBEDDED ) && !defined( OROCOS_TARGET_WIN32 )
00545 BOOST_AUTO_TEST_CASE( testExceptionRecovery )
00546 {
00547     Logger::LogLevel ll = Logger::log().getLogLevel();
00548     Logger::log().setLogLevel( Logger::Never );
00549     BOOST_CHECK(t_task_np->start());
00550     BOOST_CHECK(t_task_np_bad->start()); // must stop t_task_np too.
00551     BOOST_CHECK(t_task_p->start());
00552     BOOST_CHECK(t_task_a->start());
00553 
00554     usleep(100000);
00555 
00556     // thread should stop :
00557     Logger::log().setLogLevel( ll );
00558     BOOST_CHECK( !t_task_np_bad->thread()->isRunning() );
00559 
00560     // This sometimes fails because of a bug in gnulinux Thread/fosi:
00561     // two TimerThreads are created because the first one is not yet
00562     // running, hence np_bad runs in a different thread than np...
00563     BOOST_CHECK( !t_task_np->isRunning() );
00564     BOOST_CHECK( !t_task_np_bad->isRunning() );
00565     BOOST_CHECK( t_task_p->isRunning() );
00566     BOOST_CHECK( !t_task_a->isRunning() );
00567 
00568     BOOST_CHECK( t_task_np->init );
00569     BOOST_CHECK( t_task_np_bad->init );
00570     BOOST_CHECK( t_task_p->init );
00571     BOOST_CHECK( t_task_a->init );
00572 
00573     BOOST_CHECK( t_task_np->stepped );
00574     BOOST_CHECK( t_task_np->wasrunning );
00575     BOOST_CHECK( t_task_np->wasactive );
00576 
00577     BOOST_CHECK( t_task_np_bad->stepped );
00578     BOOST_CHECK( t_task_np_bad->wasrunning );
00579     BOOST_CHECK( t_task_np_bad->wasactive );
00580 
00581     BOOST_CHECK( t_task_p->stepped );
00582     BOOST_CHECK( t_task_p->wasrunning );
00583     BOOST_CHECK( t_task_p->wasactive );
00584 
00585     BOOST_CHECK( t_task_a->stepped );
00586     BOOST_CHECK( t_task_a->wasrunning );
00587     BOOST_CHECK( t_task_a->wasactive );
00588 
00589     // must be stopped since bad throwed an exception
00590     BOOST_CHECK( t_task_np->fini );
00591     BOOST_CHECK( t_task_np_bad->fini );
00592     BOOST_CHECK( t_task_a->fini );
00593 
00594     t_task_p->stop();
00595 
00596     // see if we recovered ok :
00597     Logger::log().setLogLevel( Logger::Never );
00598     // do not start np_bad
00599     BOOST_CHECK(t_task_np->start());
00600     BOOST_CHECK(t_task_a->start());
00601 
00602     usleep(100000);
00603     Logger::log().setLogLevel( ll );
00604     t_task_p->reset(true);
00605     BOOST_CHECK( t_task_np->isRunning() );
00606     BOOST_CHECK( t_task_np->init );
00607     BOOST_CHECK( t_task_np->stepped );
00608     BOOST_CHECK( t_task_np->wasrunning );
00609     BOOST_CHECK( t_task_np->wasactive );
00610 
00611     BOOST_CHECK(t_task_np->stop());
00612     BOOST_CHECK( t_task_np->fini );
00613 }
00614 #endif
00615 
00616 BOOST_AUTO_TEST_SUITE_END()
00617