ck_num.cpp

一个不错

 if(Wy::_sqrt(NumT(99))!=9) {
   WY_THROW( WyRet() );
 }
 if(Wy::_sqrt(NumT(100))!=10) {
   WY_THROW( WyRet() );
 }
 if(Wy::_sqrt(NumT(120))!=10) {
   WY_THROW( WyRet() );
 }
 if(Wy::_sqrt(NumT(121))!=11) {
   WY_THROW( WyRet() );
 }
 for(int i=0; i<=255; ++i) {  // chk i in char range
   NumT res=Wy::_sqrt((NumT)i);
   int q(res),t2(q*q);
   if(t2>i) {
     WY_THROW( WyRet() );
   }
   if(t2+2*q+1<=i) {
     WY_THROW( WyRet() );
   }
 }

 for(NumT i=std::numeric_limits<NumT>::max(); 
          i>=std::numeric_limits<NumT>::max()-254; --i) {
   NumT res=Wy::_sqrt(i);
   NumT q(res),t2(q*q);
   if(t2>i) {
     WY_THROW( WyRet() );
   }
   if(t2+2*q<=i-1) {
     std::cout << t2 << ", " << q << ", " << i << std::endl;
     std::cout << t2+2*q+1 << std::endl;
     WY_THROW( WyRet() );
   }
 }
};

template <typename T>
static void ck_num_frm_str(void)
{
 struct ChkSmp {
   T num;
   const char* nstr;
   size_t nstr_size;
   int    radix;
   void verify(void) const 
     {
      try {
        WyRet r;
        const char* endptr;
        T a1;
        if((r=Wy::_strnum(a1,&endptr,WyCSeg(nstr,nstr_size),radix))!=Ok) {
          WY_THROW(r);
        }
        if(a1!=num) {
          WY_THROW( WyRet() );
        }
        if(endptr-nstr!=int(nstr_size)) {
          WY_THROW( WyRet() );
        }
      }
      catch(...) {
        if((std::numeric_limits<T>::max()==std::numeric_limits<char>::max())||
           (std::numeric_limits<T>::max()==std::numeric_limits<unsigned char>::max())) {
          std::cerr << "ChkSmp{ T(" << (int)num << "),\""
                    << nstr << "\"," << nstr_size << ","
                    << radix << "}" << std::endl;
        } else {
          std::cerr << "ChkSmp{ T(" << num << "),\""
                    << nstr << "\"," << nstr_size << ","
                    << radix << "}" << std::endl;
        }
        throw;
      };
     }
 } const chk_tab[]={
  {T(0),"0",1,10}, {T(0),"+0",2,10}, {T(0),"-0",2,10},
  {T(0),"0.0",3,10},{T(0),"+0.0",4,10},{T(0),"-0.0",4,10},
  {T(0),"00.4",3,10},{T(0),"+00.0",5,10},{T(0),"-00.0",5,10},
  {T(0),"0.00",4,10},{T(0),"+0.00",5,10},{T(0),"-0.00",5,10},
  {T(0),"0.00e0",6,10},{T(0),"+0.00e0",7,10},{T(0),"-0.00e0",7,10},

  {T(1.0),"1",1,10},{T(1.0),"+1",2,10},{T(-1.0),"-1",2,10},
  {T(1.0),"1.0",3,10},{T(1.0),"+1.0",4,10},{T(-1.0),"-1.0",4,10},
  {T(1.0),"01.0",4,10},{T(1.0),"+01.0",5,10},{T(-1.0),"-01.0",5,10},
  {T(1.0),"1.00",4,10},{T(1.0),"+1.00",5,10},{T(-1.0),"-1.00",5,10},
  {T(1.0),"1.00e0",6,10},{T(1.0),"+1.00e0",7,10},{T(-1.0),"-1.00e0",7,10},
  {T(1.0),"1.00e+0",7,10},{T(1.0),"+1.00e+0",8,10},{T(-1.0),"-1.00e+0",8,10},
  {T(1.0),"1.00e-0",7,10},{T(1.0),"+1.00e-0",8,10},{T(-1.0),"-1.00e-0",8,10},

  {T(10.0),"1.00e1",6,10},{T(10.0),"+1.00e1",7,10},{T(-10.0),"-1.00e1",7,10},
  {T(10.0),"1.00e+1",7,10},{T(10.0),"+1.00e+1",8,10},{T(-10.0),"-1.00e+1",8,10},
  {T(0.1),"1.00e-1",7,10},{T(0.1),"+1.00e-1",8,10},{T(-0.1),"-1.00e-1",8,10},
 };

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

 // chk error
 {
   T tnn;
   WyRet r;
   const char *buf,*endptr;

   buf="12.34ee";
   tnn=99;
   if((r=Wy::_strnum(tnn,&endptr,WyCSeg(buf,7)))!=Wym_EBADMSG) {
     WY_THROW(r);
   }
   if(endptr-buf!=5) {
     WY_THROW( WyRet() );
   }
   if(Wy::wy_roughly_equ(tnn,12.34)==false) {
     WY_THROW( WyRet() );
   }
 }
};

template <typename NumType>
static void ck_num_float(void)
{
 ck_num_frm_str<NumType>();
};

template <typename NumType>
static void ck_num_integer(void)
{
 ck_uty<NumType>();
};

static void ck_examp1(void)
{
 WyRet r;
 const char* endptr;

 // chk size_t overflow (debug case)
 {
   WyCSeg txt="9876543210";
   size_t val;
   if((r=Wy::_strnum(val,&endptr,txt,0))!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 }

 // chk signed long overflow (debug case)
 {
   WyCSeg txt="-5000000000";
   signed long val;
   if((r=Wy::_strnum(val,&endptr,txt,0))!=Wym_ERANGE) {
     WY_THROW( WyRet() );
   }
 }

 // Evaluate the code to parse number " 12/23/44.4  56,456.21 4k22"
 //
 const char nstr[]=" 12/23/44.4  56,456.21 4k22";
 const char* const nstr_end=nstr+sizeof(nstr)-1;
 int v_int;
 double v_double;
 unsigned int v_uint;
 WyCSeg cs(nstr+1,sizeof(nstr)-3);

 if((r=Wy::_strnum(v_int,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if(v_int!=12) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+3) {
   WY_THROW( WyRet() );
 }
 
 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_uint,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if(v_uint!=23) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+6) {
   WY_THROW( WyRet() );
 }

 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_double,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if((v_double<44.39)||(v_double>44.41)) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+11) {
   WY_THROW( WyRet() );
 }

 ++endptr;
 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_int,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if(v_int!=56) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+15) {
   WY_THROW( WyRet() );
 }

 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_double,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if((v_double<456.209)||(v_double>456.211)) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+22) {
   WY_THROW( WyRet() );
 }
 v_double+= 1000.0*v_int;   // i.e. 56456.21

 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_uint,&endptr,cs))!=Wym_EBADMSG) {
   WY_THROW(r);
 }
 if(v_uint!=4) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+24) {
   WY_THROW( WyRet() );
 }

 ++endptr;
 cs.reset(endptr,nstr_end-endptr);
 if((r=Wy::_strnum(v_uint,&endptr,cs))!=Ok) {
   WY_THROW(r);
 }
 if(v_uint!=22) {
   WY_THROW( WyRet() );
 }
 if(endptr!=nstr+27) {
   WY_THROW( WyRet() );
 }
};

static void t_scanum(void)
{
 WyRet r;

  // chk _scanum(ValueType&,size_t&,const WyCSeg&)
  {
    const char Input1[]=" -12.34	 345.67E-1	 78.901e1 555";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    float value_f1,value_f2;
    double value_lf;
    int   value_d;

    // This loop is to use break to exit the block
    //
    do {
      if((r=Wy::_scanum(value_f1,fidx,txt))!=Ok) {
        WY_HERE(r);
        break;
      }

      if((r=Wy::_scanum(value_f2,fidx,txt))!=Ok) {
        WY_HERE(r);
        break;
      }

      if((r=Wy::_scanum(value_lf,fidx,txt))!=Ok) {
        WY_HERE(r);
        break;
      }

      if((r=Wy::_scanum(value_d,fidx,txt))!=Ok) {
        WY_HERE(r);
        break;
      }

      r=Ok;
    } while(false);
 
    if(r!=Ok) {
      WY_THROW(r);
    }
    
    float v_f1,v_f2;
    double v_lf;
    int v_d;
    if(std::sscanf(txt.begin(),"%f %f %lf %d",
                   &v_f1,&v_f2,&v_lf,&v_d)!=4) {
      WY_THROW( WyRet() );
    }
    if(::fabs(v_f1-value_f1)>0.001) {
      WY_THROW( WyRet() );
    }
    if(::fabs(v_f2-value_f2)>0.001) {
      WY_THROW( WyRet() );
    }
    if(::fabsl(v_lf-value_lf)>0.00001) {
      WY_THROW( WyRet() );
    }
    if(v_d!=value_d) {
      WY_THROW( WyRet() );
    }
  }

  // chk _scanum(ValueType&,size_t&,const WyCSeg&,const int&)
  {
    const char Input1[]="ffff 	222";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    unsigned int  value_x1, value_x2;

    if((r=Wy::_scanum(value_x1,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }
    if((r=Wy::_scanum(value_x2,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }

    unsigned int v_x1,v_x2;
    if(std::sscanf(txt.begin(),"%x %x",
                   &v_x1,&v_x2)!=2) {
      WY_THROW( WyRet() );
    }
    if(value_x1!=v_x1) {
      WY_THROW( WyRet() );
    }
    if(value_x2!=v_x2) {
      WY_THROW( WyRet() );
    }
  }

  // chk reply
  {
    WyCSeg txt;
    size_t fidx=100;
    size_t value;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ENOENT) {
      WY_THROW( WyRet() );
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }

    txt="9876543210";
    fidx=0;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ERANGE) {
      WY_THROW( WyRet() );
    }
    if(fidx!=0) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value,fidx,txt,37))!=Wym_EINVAL) {
      WY_THROW( WyRet() );
    }
    if((r=Wy::_scanum(value,fidx,txt,1))!=Wym_EINVAL) {
      WY_THROW( WyRet() );
    }
  }
};

template <typename NumType>
static void ck_scanum_integer(void)
{
 WyRet r;

  // chk _scanum(ValueType&,size_t&,const WyCSeg&)
  {
    const char Input1[]=" 43	 123	 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if(value_f1!=(NumType)43) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if(value_f2!=(NumType)123) {
      WY_THROW( WyRet() );
    }
  }

  if(std::numeric_limits<NumType>::is_signed) {
    const char Input1[]="-43	 -123	 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if(value_f1!=(NumType)-43) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if(value_f2!=(NumType)-123) {
      WY_THROW( WyRet() );
    }
  }

  // chk _scanum(ValueType&,size_t&,const WyCSeg&,const int&)
  {
    const char Input1[]=" a3	 2f	 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }
    if(value_f1!=(NumType)0xa3) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }
    if(value_f2!=(NumType)0x2f) {
      WY_THROW( WyRet() );
    }
  }
  if(std::numeric_limits<NumType>::is_signed) {
    const char Input1[]=" -a3	 -2f	 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }
    if(value_f1!=(NumType)-0xa3) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt,16))!=Ok) {
      WY_THROW(r);
    }
    if(value_f2!=(NumType)-0x2f) {
      WY_THROW( WyRet() );
    }
  }

  // chk reply
  {
    WyCSeg txt;
    NumType value;
    size_t fidx=100;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ENOENT) {
      WY_THROW( WyRet() );
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }
    if((r=Wy::_scanum(value,fidx,txt,16))!=Wym_ENOENT) {
      WY_THROW( WyRet() );
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }

    txt="98765432100000000000";
    fidx=0;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ERANGE) {
      WY_THROW(r);
    }
    if(fidx!=0) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value,fidx,txt,37))!=Wym_EINVAL) {
      WY_THROW(r);
    }
    if((r=Wy::_scanum(value,fidx,txt,1))!=Wym_EINVAL) {
      WY_THROW(r);
    }
  }
};

template <typename NumType>
static void ck_scanum_float(void)
{
 WyRet r;

  // chk _scanum(ValueType&,size_t&,const WyCSeg&)
  {
    const char Input1[]=" 43.67	 -123e-2 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if( ::fabsl(value_f1-(double)43.67)>1e-5 ) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt))!=Ok) {
      WY_THROW(r);
    }
    if( ::fabsl(value_f2- (double)-123e-2)>1e-5 ) {
      WY_THROW( WyRet() );
    }
  }

  // chk _scanum(ValueType&,size_t&,const WyCSeg&,const int&)
  {
    const char Input1[]="1.234	 5.78e+2	 ";
    const WyCSeg txt=Input1;
    size_t fidx=0;
    NumType value_f1,value_f2;

    if((r=Wy::_scanum(value_f1,fidx,txt,0))!=Ok) {
      WY_THROW(r);
    }
    if( ::fabsl(value_f1- (double)1.234)>1e-5 ) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value_f2,fidx,txt,0))!=Ok) {
      WY_THROW(r);
    }
    if( ::fabsl(value_f2- (double)5.78e+2)>1e-5 ) {
      WY_THROW( WyRet() );
    }
  }

  // chk reply
  {
    WyCSeg txt;
    NumType value;
    size_t fidx=100;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ENOENT) {
      WY_THROW( WyRet() );
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }
    if((r=Wy::_scanum(value,fidx,txt,0))!=Wym_ENOENT) {
      WY_THROW(r);
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }

    txt="987654321e9999";
    fidx=0;
    if((r=Wy::_scanum(value,fidx,txt))!=Wym_ERANGE) {
      WY_THROW(r);
    }
    if(fidx!=0) {
      WY_THROW( WyRet() );
    }

    if((r=Wy::_scanum(value,fidx,txt,37))!=Wym_EINVAL) {
      WY_THROW(r);
    }
    if((r=Wy::_scanum(value,fidx,txt,1))!=Wym_EINVAL) {
      WY_THROW(r);
    }
    if((r=Wy::_scanum(value,fidx,txt,16))!=Wym_EINVAL) {
      WY_THROW(r);
    }
  }
};

void ck_num(void)
{
 ck_strnum();

 ck_num_integer<char>(); 
 ck_num_integer<short int>();
 ck_num_integer<int>();
 ck_num_integer<long int>();
 ck_num_integer<long long int>();

 ck_num_integer<signed char>();
 ck_num_integer<signed short int>();
 ck_num_integer<signed int>();
 ck_num_integer<signed long int>();
 ck_num_integer<signed long long int>();

 ck_num_integer<unsigned char>();
 ck_num_integer<unsigned short int>();
 ck_num_integer<unsigned int>();
 ck_num_integer<unsigned long int>();
 ck_num_integer<unsigned long long int>();

 ck_num_float<float>();
 ck_num_float<double>();

 ck_sqrt<unsigned char>();
 ck_sqrt<unsigned short>();
 ck_sqrt<unsigned int>();
 ck_sqrt<unsigned long int>();
 ck_sqrt<unsigned long long int>();

 ck_examp1();
 t_scanum();
 ck_scanum_integer<char>();
 ck_scanum_integer<signed char>();
 ck_scanum_integer<signed short>();
 ck_scanum_integer<signed int>();
 ck_scanum_integer<signed long>();
 ck_scanum_integer<signed long long>();
 ck_scanum_integer<unsigned char>();
 ck_scanum_integer<unsigned short>();
 ck_scanum_integer<unsigned int>();
 ck_scanum_integer<unsigned long>();
 ck_scanum_integer<unsigned long long>();
 ck_scanum_float<float>();
 ck_scanum_float<double>();
};