ck_timespec.cpp

一个不错

   WyTimeSpec ttm(MaxSecond,0);
   ttm+=WyTimeSpec(1,1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };
 try {
   WyTimeSpec ttm(MinSecond,0);
   ttm+=WyTimeSpec(-1,0);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 // operator-=(WyTimeSpec)
 //
 try {
   WyTimeSpec ttm(MinSecond,0);
   ttm-=WyTimeSpec(1,1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };
 try {
   WyTimeSpec ttm(MaxSecond,0);
   ttm-=WyTimeSpec(-1,0);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 // operator+(WyTimeSpec)
 //
 try {
   WyTimeSpec ttm(MaxSecond,0);
   ttm=ttm+WyTimeSpec(1,1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 // operator-(WyTimeSpec)
 //
 try {
   WyTimeSpec ttm(MinSecond,0);
   ttm=ttm-WyTimeSpec(1,1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 // abs()
 //
 try {
   WyTimeSpec ttm(MinSecond,0);
   ttm.abs();
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_EMATHNEG) {
     WY_THROW( WyRet() );
   }
 };

 // Test add(long ,long) overflow 
 //
 {
  WyTimeSpec ttm(MaxSecond,999999999L);   // maximum value
  WyRet r;
  if((r=ttm.add(Wy_Second(),Wy_Nano()))!=Ok) {
     WY_THROW( WyRet() );
  }
  if((r=ttm.add(1,Wy_Nano()))!=Wym_ERANGE) {
     WY_THROW( WyRet() );
  }
  if(ttm!=WyTimeSpec(MaxSecond,999999999L)) {
     WY_THROW( WyRet() );     // error modified
  }
  if((r=ttm.add(Wy_Second(),1))!=Wym_ERANGE) {
     WY_THROW( WyRet() );
  }
  if(ttm!=WyTimeSpec(MaxSecond,999999999L)) {
     WY_THROW( WyRet() );     // error modified
  }

  {
    WyTimeSpec tmp(1,MaxNano);
    if(tmp.add(1,MaxNano)!=Ok) {
      WY_THROW(r);
    }
    if(tmp.sub(1,MaxNano)!=Ok) {
      WY_THROW(r);
    }
    if(tmp!=WyTimeSpec(1,MaxNano)) {
       WY_THROW( WyRet() );
    }
  }

  {
    WyTimeSpec tmp(1,MinNano);
    if(tmp.add(1,MinNano)!=Ok) {
      WY_THROW(r);
    }
    if(tmp.sub(1,MinNano)!=Ok) {
      WY_THROW(r);
    }
    if(tmp!=WyTimeSpec(1,MinNano)) {
       WY_THROW( WyRet() );
    }
  }
 }

 // Test add(WyTimeSpec) overflow
 //
 {
  WyTimeSpec ttm(MaxSecond,999999999L);   // maximum value
  WyRet r;
  if((r=ttm.add( WyTimeSpec(Wy_Second(),1) ))!=Wym_ERANGE) {
     WY_THROW(r);
  }
  if(ttm!=WyTimeSpec(MaxSecond,999999999L)) {
     WY_THROW( WyRet() );     // error modified
  }
 }

 // Test =(const char*)
 try {
   WyTimeSpec ttm(1,0);
   ttm="9a";
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_EBADMSG) {
     WY_THROW( WyRet() );
   }
 };

 //
 // Test +=WyTimeSpec overflow
 //
 try {
   WyTimeSpec ttm(MaxSecond,999999999L);
   ttm+=WyTimeSpec(Wy_Second(),1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 //
 // Test WyTimeSpec + WyTimeSpec overflow
 //
 try {
   WyTimeSpec ttm(MaxSecond,999999999L);
   ttm=ttm+WyTimeSpec(Wy_Second(),1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 //
 // Test WyTimeSpec - WyTimeSpec underflow
 //
 try {
   WyTimeSpec ttm(MinSecond,-999999999L);
   ttm=ttm-WyTimeSpec(Wy_Second(),1);
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 };

 // 
 // Test operator -() failure condition
 //
 try {
   WyTimeSpec ttm(MinSecond,Wy_Nano());   // negate MinSecond should fail
   ttm=-ttm;
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_EMATHNEG) {
     WY_THROW( WyRet() );
   }
 };

 // 
 // Test operator -() failure condition
 //
 try {
   WyTimeSpec ttm(MinSecond,Wy_Nano());   // negate MinSecond should fail
   ttm=-ttm;
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_EMATHNEG) {
     WY_THROW( WyRet() );
   }
 };

 // don't know how to generate get_time/set_time error
};

// Test random time arithmatic operations
//
static void t3(void)
{
 WyRet r;
 WyTimeSpec t1,t2,t3,t4,tt;
 long i;
 for(i=100000L; i>0; --i) {
   t1=WyTimeSpec(Wy_Second(std::rand()%MaxL2),Wy_Nano(std::rand()));
   t2=WyTimeSpec(Wy_Second(std::rand()%MaxL2),Wy_Nano(std::rand()));
   t3=t1+t2;
   t4=t1-t2;
   tt=t3+t4;
   if(tt!=t1+t1) {
     WY_HERE(r);
     break;
   }
   tt=t4-t3;
   if(tt!=-t2-t2) {
     WY_HERE(r);
     break;
   }
 }
 if(i>0) { // premature break, error happened
   std::cout << " t1= " << Wy::wrd(t1).c_str()
             << "\n t2= " << Wy::wrd(t2).c_str()
             << "\n t3= " << Wy::wrd(t3).c_str()
             << "\n t4= " << Wy::wrd(t4).c_str()
             << "\n tt= " << Wy::wrd(tt).c_str()
             << std::endl;
   WY_THROW(r);
 }
};

//
//   Test the ensured range LLONG_MAX+0.999999999
//
static void t4(void) 
{
const WyTimeSpec WorkMax(MaxSecond,999999999L);
const WyTimeSpec WorkMin(-MaxSecond,-999999999L);
WyTimeSpec t1;

 //
 // Test -WorkMin
 //
 t1=-WorkMin;
 if(t1!=WorkMax) {
   WY_THROW( WyRet() );
 }

 //
 // Test -WorkMax
 //
 t1=-WorkMax;
 if(t1!=WorkMin) {
   WY_THROW( WyRet() );
 }

 //
 // Test WorkMax - 1nano
 //
 t1=WorkMax-WyTimeSpec(Wy_Second(),1);
 if(t1>=WorkMax) {
   WY_THROW( WyRet() );
 }
 t1+=WyTimeSpec(Wy_Second(),1);
 if(t1!=WorkMax) {
   WY_THROW( WyRet() );
 }

 //
 // Test WorkMax - 1sec
 //
 t1=WorkMax-WyTimeSpec(Wy_Second(1),Wy_Nano());
 if(t1>=WorkMax) {
   WY_THROW( WyRet() );
 }
 t1+=WyTimeSpec(1,Wy_Nano());
 if(t1!=WorkMax) {
   WY_THROW( WyRet() );
 }

 //
 // Test WorkMin + 1nano
 //
 t1=WorkMin+WyTimeSpec(Wy_Second(),1);
 if(t1<=WorkMin) {
   WY_THROW( WyRet() );
 }
 t1-=WyTimeSpec(Wy_Second(),1);
 if(t1!=WorkMin) {
   WY_THROW( WyRet() );
 }

 //
 // Test WorkMin + 1sec
 //
 t1=WorkMin+WyTimeSpec(1,Wy_Nano());
 if(t1<=WorkMin) {
   WY_THROW( WyRet() );
 }
 t1-=WyTimeSpec(1,Wy_Nano());
 if(t1!=WorkMin) {
   WY_THROW( WyRet() );
 }

 //
 // Constructor Wym_ERANGE
 //
 try {
   WyTimeSpec ttm(MaxSecond,LongMax);
   ttm.reset();   // supress compiler waring from above
   WY_THROW( WyRet() ); 
 }
 catch(const WyTimeSpec::Reply& e) {
   if(e!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 }
 catch(...) {
   std::cerr << "Exception Leaked" << std::endl;
 };
}

//
// Check sleep_till
//
#ifdef TEST_SLEEP_TILL
static void t5(void)
{
 WyTimeSpec t0=Wy::now();
 WyRet r=Wy::sleep_till(t0+WyTimeSpec(1,Wy_Nano())); // delay one second
 if(r!=Wym_ETIMEDOUT) {
   WY_THROW(r);
 }
 WyTimeSpec t1=Wy::now()-t0;
 if(  (t1<WyTimeSpec(Wy_Second(),Wy_Nano(940000000L)))      // 0.94 sec
    ||(t1>WyTimeSpec(Wy_Second(1),Wy_Nano(60000000L)))) {   // 1.06 sec
   std::cerr << "sleep_till(...) inaccurate delay, " << Wy::wrd(t1).c_str()
             << IAMsg.begin();
   //WY_THROW( WyRet() );    
 }
};
#endif

static void t_sleep(void)
{
 const WyTimeSpec OneSec(1,Wy_Nano());
 WyTimeSpec t0=Wy::now();
 WyRet r=Wy::sleep(OneSec);
 if(r!=Ok) {
   WY_THROW(r);
 }
 WyTimeSpec t1=Wy::now()-t0;
 if(  (t1<WyTimeSpec(Wy_Second(),Wy_Nano(940000000L)))      // 0.94 sec
    ||(t1>WyTimeSpec(Wy_Second(1),Wy_Nano(60000000L)))) {   // 1.06 sec
   std::cerr << "sleep(..) inaccurate delay, " << Wy::wrd(t1).c_str()
             << IAMsg.begin();
   WY_THROW( WyRet() );  // error> 0.06 sec
 }

 WyTimeSpec trem(OneSec);
 t0=Wy::now();
 r=Wy::sleep(OneSec,trem);
 if(r!=Ok) {
   WY_THROW(r);
 }
 t1=Wy::now()-t0;
 if(  (t1<WyTimeSpec(Wy_Second(),Wy_Nano(900000000L)))      // 0.9 sec
    ||(t1>WyTimeSpec(Wy_Second(1),Wy_Nano(100000000L)))) {   // 1.1 sec
   std::cerr << "sleep(..) inaccurate delay, " << Wy::wrd(t1).c_str()
             << IAMsg.begin();
   WY_THROW( WyRet() );  // error> 0.1 sec (may be OK)
 }
 if(trem!=OneSec) {
   // On Fedora3, success does not modify rem. Monter this feature.
   std::cerr << Wy::wrd(trem).c_str() << ".. feature changed\n";
 }
};

// chk _mkstr
static void t_mkstr(void)
{
 struct ChkSmp {
   const char* nstr;
   int radix;
   size_t frdig;
   WyTimeSpec nvalue;
   void verify(void) const
     {
       WyStr str("before _mkstr called");
       WyRet r;
       try {
         if((r=Wy::_mkstr(str,nvalue,radix,frdig))!=Ok) {
           WY_THROW(r);
         }
         if(str!=nstr) {
           WY_THROW( WyRet() );
         }
       }
       catch(...) {
         std::cerr << "ChkSmp={\"" << nstr << "\"," << radix << "," << frdig
              << ",WyTimeSpec(" << nvalue.second() << ","
              << nvalue.nano() << ")}, _mkstr=\""
              << str.c_str() << "\"\n";
         throw;
       };
     };
 } const chk_tab[]={
  {"0",10,0,WyTimeSpec()},{"0.0",10,1,WyTimeSpec()},{"0.00",10,2,WyTimeSpec()},
  {"1",10,0,WyTimeSpec(1,0)},{"-1",10,0,WyTimeSpec(-1,0)},{"1.0",10,1,WyTimeSpec(1,0)},
  {"26.000000501",10,9,WyTimeSpec(26,501)},
  {"21.000000054",10,9,WyTimeSpec(21,54)},
  {"1.00000",10,5,WyTimeSpec(1,5)},
  {"120.000000450",10,9,WyTimeSpec(120,450)},
  {"0.00000045",10,8,WyTimeSpec(Wy_Second(),450)},
  {"0",10,0,WyTimeSpec(Wy_Second(),450)},
  {"-0.00000045",10,8,WyTimeSpec(Wy_Second(),-450)},
  {"-1.00000045",10,8,WyTimeSpec(-1,-450)},
  {"-0.9999995500",10,10,WyTimeSpec(-1,450)},

  // radix=0
  {"0e+0",0,0,WyTimeSpec()},{"0.0e+0",0,1,WyTimeSpec()},
                            {"0.00e+0",0,2,WyTimeSpec()},
  {"1e+0",0,0,WyTimeSpec(1,0)},{"-1e+0",0,0,WyTimeSpec(-1,0)},
                            {"1.0e+0",0,1,WyTimeSpec(1,0)},
  {"2.6000000501e+1",0,10,WyTimeSpec(26,501)},
  {"2.1000000054e+1",0,10,WyTimeSpec(21,54)},
  {"1.00000e+0",0,5,WyTimeSpec(1,5)},
  {"1.2000000045e+2",0,10,WyTimeSpec(120,450)},
  {"4e-7",0,0,WyTimeSpec(Wy_Second(),450)},
  {"4.5e-7",0,1,WyTimeSpec(Wy_Second(),450)},
  {"4.50e-7",0,2,WyTimeSpec(Wy_Second(),450)},
  {"-4e-7",0,0,WyTimeSpec(Wy_Second(),-450)},
  {"-4.5e-7",0,1,WyTimeSpec(Wy_Second(),-450)},
  {"-4.50e-7",0,2,WyTimeSpec(Wy_Second(),-450)},
  {"-1.00000045e+0",0,8,WyTimeSpec(-1,-450)},
  {"-9.999995500e-1",0,9,WyTimeSpec(-1,450)},

 };

 for(size_t i=0; i<sizeof(chk_tab)/sizeof(ChkSmp); ++i) {
   chk_tab[i].verify();
 }

 WyRet r;
 WyStr str;
 if((r=Wy::_mkstr(str,WyTimeSpec(),1,0))!=Wym_EINVAL) {
   WY_THROW(r);
 }
 if((r=Wy::_mkstr(str,WyTimeSpec(),2,1))!=Wym_EINVAL) {
   WY_THROW(r);
 }
 if((r=Wy::_mkstr(str,WyTimeSpec(),8,1))!=Wym_EINVAL) {
   WY_THROW(r);
 }
 if((r=Wy::_mkstr(str,WyTimeSpec(),16,1))!=Wym_EINVAL) {
   WY_THROW(r);
 }
};

struct TestSample {
  const char* nstr;
  size_t strlen;
  WyTimeSpec nvalue;
};

static TestSample samp_tab[]= {
  {"0",1,WyTimeSpec()},{"+0",2,WyTimeSpec()},{"-0",2,WyTimeSpec()},
  {"00",2,WyTimeSpec()},{"+00",3,WyTimeSpec()},{"-00",3,WyTimeSpec()},
  {"0.0",3,WyTimeSpec()},{"+0.0",4,WyTimeSpec()},{"-0.0",4,WyTimeSpec()},
  {"0.00",4,WyTimeSpec()},{"+0.00",5,WyTimeSpec()},{"-0.00",5,WyTimeSpec()},
  {"00.00",5,WyTimeSpec()},{"+00.00",6,WyTimeSpec()},{"-00.00",6,WyTimeSpec()},
  {"0.",2,WyTimeSpec()},{"+0.",3,WyTimeSpec()},{"-0.",3,WyTimeSpec()},
  {".0",2,WyTimeSpec()},{"+.0",3,WyTimeSpec()},{"-.0",3,WyTimeSpec()},
  {"0e0",3,WyTimeSpec()},{"+0e0",4,WyTimeSpec()},{"-0e0",4,WyTimeSpec()},
  {"0e+0",4,WyTimeSpec()},{"+0e+0",5,WyTimeSpec()},{"-0e+0",5,WyTimeSpec()},
  {"0e-0",4,WyTimeSpec()},{"+0e-0",5,WyTimeSpec()},{"-0e00",5,WyTimeSpec()},

  {"12",2,WyTimeSpec(Wy_Second(12),Wy_Nano())},
  {"+12",3,WyTimeSpec(Wy_Second(12),Wy_Nano())},
  {"-12",3,WyTimeSpec(Wy_Second(-12),Wy_Nano())},

  {"12.34",5,WyTimeSpec(Wy_Second(12),Wy_Nano(340000000))},
  {"+12.34",6,WyTimeSpec(Wy_Second(12),Wy_Nano(340000000))},
  {"-12.34",6,WyTimeSpec(Wy_Second(-12),Wy_Nano(-340000000))},

  {"12.010",6,WyTimeSpec(Wy_Second(12),Wy_Nano(10000000))},
  {"+12.010",7,WyTimeSpec(Wy_Second(12),Wy_Nano(10000000))},
  {"-12.010",7,WyTimeSpec(Wy_Second(-12),Wy_Nano(-10000000))},

  {"012.34",6,WyTimeSpec(Wy_Second(12),Wy_Nano(340000000))},
  {"+012.34",7,WyTimeSpec(Wy_Second(12),Wy_Nano(340000000))},
  {"-012.34",7,WyTimeSpec(Wy_Second(-12),Wy_Nano(-340000000))},

  {"12.",3,WyTimeSpec(Wy_Second(12),Wy_Nano())},
  {"+12.",4,WyTimeSpec(Wy_Second(12),Wy_Nano())},
  {"-12.",4,WyTimeSpec(Wy_Second(-12),Wy_Nano())},

  {".12",3,WyTimeSpec(Wy_Second(),Wy_Nano(120000000))},
  {"+.12",4,WyTimeSpec(Wy_Second(),Wy_Nano(120000000))},
  {"-.12",4,WyTimeSpec(Wy_Second(),Wy_Nano(-120000000))},

  {".120",4,WyTimeSpec(Wy_Second(),Wy_Nano(120000000))},
  {"+.120",5,WyTimeSpec(Wy_Second(),Wy_Nano(120000000))},
  {"-.120",5,WyTimeSpec(Wy_Second(),Wy_Nano(-120000000))},

  {"12e1",4,WyTimeSpec(Wy_Second(120),Wy_Nano())},
  {"12e+1",5,WyTimeSpec(Wy_Second(120),Wy_Nano())},
  {"12e-1",5,WyTimeSpec(Wy_Second(1),Wy_Nano(200000000))},

  {"+12e1",5,WyTimeSpec(Wy_Second(120),Wy_Nano())},
  {"+12e+1",6,WyTimeSpec(Wy_Second(120),Wy_Nano())},
  {"+12e-1",6,WyTimeSpec(Wy_Second(1),Wy_Nano(200000000))},

  {"-12e1",5,WyTimeSpec(Wy_Second(-120),Wy_Nano())},