cpp/test/IceUtil/timer/Client.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <IceUtil/Timer.h>
  11 #include <TestCommon.h>
  12
  13 #include <vector>
  14
  15 using namespace IceUtil;
  16 using namespace std;
  17
  18 class TestTask : public IceUtil::TimerTask, IceUtil::Monitor<IceUtil::Mutex>
  19 {
  20 public:
  21
  22     TestTask() : _count(0)
  23     {
  24     }
  25
  26     TestTask(const IceUtil::Time& scheduledTime) : _scheduledTime(scheduledTime), _count(0)
  27     {
  28     }
  29
  30     virtual void
  31     runTimerTask()
  32     {
  33         Lock sync(*this);
  34         ++_count;
  35         _run = IceUtil::Time::now(IceUtil::Time::Monotonic);
  36         //cerr << "run: " << _scheduledTime.toMilliSeconds() << " " << _run.toMilliSeconds() << endl;
  37         notifyAll();
  38     }
  39
  40     virtual bool
  41     operator<(const TestTask& r) const
  42     {
  43         return _scheduledTime < r._scheduledTime;
  44     }
  45
  46     virtual bool
  47     hasRun() const
  48     {
  49         Lock sync(*this);
  50         return _run != IceUtil::Time();
  51     }
  52
  53     int
  54     getCount() const
  55     {
  56         Lock sync(*this);
  57         return _count;
  58     }
  59
  60     virtual IceUtil::Time
  61     getRunTime() const
  62     {
  63         Lock sync(*this);
  64         return _run;
  65     }
  66
  67     IceUtil::Time
  68     getScheduledTime() const
  69     {
  70         return _scheduledTime;
  71     }
  72
  73     virtual void
  74     waitForRun()
  75     {
  76         Lock sync(*this);
  77         while(_run == IceUtil::Time())
  78         {
  79             if(!timedWait(IceUtil::Time::seconds(10)))
  80             {
  81                 test(false); // Timeout.
  82             }
  83         }
  84     }
  85
  86     void
  87     clear()
  88     {
  89         _run = IceUtil::Time();
  90         _count = 0;
  91     }
  92
  93 private:
  94
  95     IceUtil::Time _run;
  96     IceUtil::Time _scheduledTime;
  97     int _count;
  98 };
  99 typedef IceUtil::Handle<TestTask> TestTaskPtr;
 100
 101
 102 class DestroyTask : public IceUtil::TimerTask, IceUtil::Monitor<IceUtil::Mutex>
 103 {
 104 public:
 105
 106     DestroyTask(const IceUtil::TimerPtr& timer) : _timer(timer), _run(false)
 107     {
 108     }
 109
 110     virtual void
 111     runTimerTask()
 112     {
 113         Lock sync(*this);
 114         _timer->destroy();
 115         _run = true;
 116         notify();
 117     }
 118
 119     virtual void
 120     waitForRun()
 121     {
 122         Lock sync(*this);
 123         while(!_run)
 124         {
 125             if(!timedWait(IceUtil::Time::seconds(10)))
 126             {
 127                 test(false); // Timeout.
 128             }
 129         }
 130     }
 131
 132 private:
 133
 134     IceUtil::TimerPtr _timer;
 135     bool _run;
 136 };
 137 typedef IceUtil::Handle<DestroyTask> DestroyTaskPtr;
 138
 139 int main(int argc, char* argv[])
 140 {
 141     cout << "testing timer... " << flush;
 142     {
 143         IceUtil::TimerPtr timer = new IceUtil::Timer();
 144
 145         {
 146             TestTaskPtr task = new TestTask();
 147             timer->schedule(task, IceUtil::Time());
 148             task->waitForRun();
 149             task->clear();
 150
 151             //
 152             // Verify that the same task cannot be scheduled more than once.
 153             //
 154             timer->schedule(task, IceUtil::Time::milliSeconds(100));
 155             try
 156             {
 157                 timer->schedule(task, IceUtil::Time());
 158             }
 159             catch(const IceUtil::IllegalArgumentException&)
 160             {
 161                 // Expected.
 162             }
 163             task->waitForRun();
 164             task->clear();
 165         }
 166
 167         {
 168             TestTaskPtr task = new TestTask();
 169             test(!timer->cancel(task));
 170             timer->schedule(task, IceUtil::Time::seconds(1));
 171             test(!task->hasRun() && timer->cancel(task) && !task->hasRun());
 172             test(!timer->cancel(task));
 173             IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1100));
 174             test(!task->hasRun());
 175         }
 176
 177         {
 178             vector<TestTaskPtr> tasks;
 179             IceUtil::Time start = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::milliSeconds(500);
 180             for(int i = 0; i < 20; ++i)
 181             {
 182                 tasks.push_back(new TestTask(IceUtil::Time::milliSeconds(500 + i * 5)));
 183             }
 184
 185             random_shuffle(tasks.begin(), tasks.end());
 186             vector<TestTaskPtr>::const_iterator p;
 187             for(p = tasks.begin(); p != tasks.end(); ++p)
 188             {
 189                 timer->schedule(*p, (*p)->getScheduledTime());
 190             }
 191
 192             for(p = tasks.begin(); p != tasks.end(); ++p)
 193             {
 194                 (*p)->waitForRun();
 195             }
 196
 197             test(IceUtil::Time::now(IceUtil::Time::Monotonic) > start);
 198
 199             sort(tasks.begin(), tasks.end());
 200             for(p = tasks.begin(); p + 1 != tasks.end(); ++p)
 201             {
 202                 if((*p)->getRunTime() > (*(p + 1))->getRunTime())
 203                 {
 204                     test(false);
 205                 }
 206             }
 207         }
 208
 209         {
 210             TestTaskPtr task = new TestTask();
 211             timer->scheduleRepeated(task, IceUtil::Time::milliSeconds(20));
 212             IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
 213             test(task->hasRun());
 214             test(task->getCount() > 1);
 215             test(task->getCount() < 26);
 216             test(timer->cancel(task));
 217             int count = task->getCount();
 218             IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
 219             test(count == task->getCount() || count + 1 == task->getCount());
 220         }
 221
 222         timer->destroy();
 223     }
 224     cout << "ok" << endl;
 225
 226     cout << "testing timer destroy... " << flush;
 227     {
 228         {
 229             IceUtil::TimerPtr timer = new IceUtil::Timer();
 230             DestroyTaskPtr destroyTask = new DestroyTask(timer);
 231             timer->schedule(destroyTask, IceUtil::Time());
 232             destroyTask->waitForRun();
 233             try
 234             {
 235                 timer->schedule(destroyTask, IceUtil::Time());
 236             }
 237             catch(const IceUtil::IllegalArgumentException&)
 238             {
 239                 // Expected;
 240             }
 241         }
 242         {
 243             IceUtil::TimerPtr timer = new IceUtil::Timer();
 244             TestTaskPtr testTask = new TestTask();
 245             timer->schedule(testTask, IceUtil::Time());
 246             timer->destroy();
 247             try
 248             {
 249                 timer->schedule(testTask, IceUtil::Time());
 250             }
 251             catch(const IceUtil::IllegalArgumentException&)
 252             {
 253                 // Expected;
 254             }
 255         }
 256     }
 257     cout << "ok" << endl;
 258
 259     return EXIT_SUCCESS;
 260 }