ck_uty.cpp

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2005

   Test functions in wy_uty.h
*/

#include "wyret.h"
#include "wyregfile.h"
#include "wyfifofile.h"
#include "wy_uty.h"
#include <math.h>    // for fabs
#include <cstdio>    // for sscanf

static void t1(void)
{
 WyFifoFile ff_rd,ff_wr;
 WyRet r;

 if((WyFifoFile::mkpipe(ff_rd,ff_wr))!=Ok) {
   WY_THROW(r);
 }

 // basic built-in type (write)
 {
   char ch;
   WyStr str;
   ff_wr << char('a');
   ff_rd >> ch;
   if(ch!='a') {
     WY_THROW( WyRet() );
   }

   ff_wr << (signed char)-123;
   ff_rd >> str;
   if(str!="-123") {
     WY_THROW( WyRet() );
   }
   ff_wr << (signed short)-122;
   ff_rd >> str;
   if(str!="-122") {
     WY_THROW( WyRet() );
   }
   ff_wr << (signed int)-121;
   ff_rd >> str;
   if(str!="-121") {
     WY_THROW( WyRet() );
   }
   ff_wr << (signed long)-120;
   ff_rd >> str;
   if(str!="-120") {
     WY_THROW( WyRet() );
   }
   ff_wr << (signed long long)-119;
   ff_rd >> str;
   if(str!="-119") {
     WY_THROW( WyRet() );
   }

   ff_wr << (unsigned char)123;
   ff_rd >> str;
   if(str!="123") {
     WY_THROW( WyRet() );
   }
   ff_wr << (unsigned short)122;
   ff_rd >> str;
   if(str!="122") {
     WY_THROW( WyRet() );
   }
   ff_wr << (unsigned int)121;
   ff_rd >> str;
   if(str!="121") {
     WY_THROW( WyRet() );
   }
   ff_wr << (unsigned long)120;
   ff_rd >> str;
   if(str!="120") {
     WY_THROW( WyRet() );
   }
   ff_wr << (unsigned long long)119;
   ff_rd >> str;
   if(str!="119") {
     WY_THROW( WyRet() );
   }
   ff_wr << (float)4.5;
   ff_rd >> str;
   if(str!="4.500000") {
     WY_THROW( WyRet() );
   }
   ff_wr << (double)3.5;
   ff_rd >> str;
   if(str!="3.500000") {
     WY_THROW( WyRet() );
   }

   // 
   ff_wr << "23456";
   ff_rd >> ch;
   if(ch!='2') {
     WY_THROW( WyRet() );
   }
   ff_rd >> ch;
   if(ch!='3') {
     WY_THROW( WyRet() );
   }
   ff_rd >> ch;
   if(ch!='4') {
     WY_THROW( WyRet() );
   }
   unsigned char uch;
   ff_rd >> uch;
   if(uch!='5') {
     WY_THROW( WyRet() );
   }
   signed char sch;
   ff_rd >> sch;
   if(sch!='6') {
     WY_THROW( WyRet() );
   }
 }

 // basic built-in type (wrd)
 {
   char ch;
   WyStr str;
   ff_wr << Wy::wrd((char)8);
   ff_rd >> ch;
   if(ch!='8') {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((signed char)'a');
   ff_rd >> str;
   if(str!="97") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((unsigned char)'a');
   ff_rd >> str;
   if(str!="97") {
     WY_THROW( WyRet() );
   }

   ff_wr << Wy::wrd((signed char)-123);
   ff_rd >> str;
   if(str!="-123") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((signed short)-122);
   ff_rd >> str;
   if(str!="-122") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((signed int)-121);
   ff_rd >> str;
   if(str!="-121") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((signed long)-120);
   ff_rd >> str;
   if(str!="-120") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((signed long long)-119);
   ff_rd >> str;
   if(str!="-119") {
     WY_THROW( WyRet() );
   }

   ff_wr << Wy::wrd((unsigned char)123);
   ff_rd >> str;
   if(str!="123") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((unsigned short)122);
   ff_rd >> str;
   if(str!="122") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((unsigned int)121);
   ff_rd >> str;
   if(str!="121") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((unsigned long)120);
   ff_rd >> str;
   if(str!="120") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((unsigned long long)119);
   ff_rd >> str;
   if(str!="119") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((float)4.5);
   ff_rd >> str;
   if(str!="4.500000") {
     WY_THROW( WyRet() );
   }
   ff_wr << Wy::wrd((double)3.5);
   ff_rd >> str;
   if(str!="3.500000") {
     WY_THROW( WyRet() );
   }

   // 
   ff_wr << Wy::wrd((long)234);
   ff_rd >> ch;
   if(ch!='2') {
     WY_THROW( WyRet() );
   }
   ff_rd >> ch;
   if(ch!='3') {
     WY_THROW( WyRet() );
   }
   ff_rd >> ch;
   if(ch!='4') {
     WY_THROW( WyRet() );
   }

   // chk << const void*
   {
     const int stmp[]={0,5,0};
     WyStr tstr(WyCSeg("0x",2));
     if((r=Wy::_catstr(tstr,(unsigned int)stmp,int(16)))!=Ok) {
       WY_THROW(r);
     }
     ff_wr << stmp;
     ff_rd >> str;
     if(str!=tstr) {
       WY_THROW( WyRet() );
     }
   }
 }

 // chk >> str
 {
   WyRegFile tmp(__FILE__,O_RDONLY);  // this file
   WyStr str;
   size_t o_cap( str._capacity() );
   const char* o_buf( str.data() );
   if(str.size()!=0) {
     WY_THROW( WyRet() );
   }
   tmp >> str;
   if(   (str.size()!=o_cap)      // not read cap characters
       &&(str._capacity()!=o_cap) // capacity changed
       &&(str.data()!=o_buf)) {   // reallocation occurred
     WY_THROW( WyRet() );
   }
   if(Wy::_strcmp(str.cseg(0,12),WyCSeg("/* Copyright"))!=0) {
     WY_THROW( WyRet() );
   }
   
   for(;;) {
     tmp >> str;
     if(str.size()==0) {
       break;
     }
   }
 }

 // full_read/writr_all(WyByteFlow&,const void*,size_t,size_t&)
 {
   const char tdata[]="1234244";
   char rbuf[sizeof(tdata)];
   size_t n_rw;
   if((r=Wy::full_write(ff_wr,tdata,sizeof(tdata),n_rw))!=Ok) {
     WY_THROW(r);
   }
   if(n_rw!=sizeof(tdata)) {
     WY_THROW( WyRet() );
   }
   n_rw=999;
   if((r=Wy::full_read(ff_rd,rbuf,sizeof(rbuf),n_rw))!=Ok) {
     WY_THROW(r);
   }
   if(n_rw!=sizeof(rbuf)) {
     WY_THROW( WyRet() );
   }

   WyByteFlow tmpbf;
   if((r=Wy::full_write(tmpbf,tdata,sizeof(tdata),n_rw))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rw!=0) {
     WY_THROW( WyRet() );
   }
   n_rw=99;
   if((r=Wy::full_read(tmpbf,rbuf,sizeof(rbuf),n_rw))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rw!=0) {
     WY_THROW( WyRet() );
   }
 }

 // full_read(..,WyStr&,size_t) /full_write(..,const WyStr&, size_t&)
 {
   const WyStr tstr("1234244abdftlk");
   WyStr rbuf;
   size_t n_rw;
   if((r=Wy::full_write(ff_wr,tstr,n_rw))!=Ok) {
     WY_THROW(r);
   }
   if(n_rw!=tstr.size()) {
     WY_THROW( WyRet() );
   }
   if((r=Wy::full_read(ff_rd,rbuf,tstr.size()))!=Ok) {
     WY_THROW(r);
   }
   if(rbuf!=tstr) {
     WY_THROW( WyRet() );
   }

   if((r=Wy::full_write(ff_wr,tstr.cseg(),n_rw))!=Ok) {
     WY_THROW(r);
   }
   if(n_rw!=tstr.size()) {
     WY_THROW( WyRet() );
   }
   rbuf.reset();
   if((r=Wy::full_read(ff_rd,rbuf,tstr.size()))!=Ok) {
     WY_THROW(r);
   }
   if(rbuf!=tstr) {
     WY_THROW( WyRet() );
   }

   WyByteFlow tmpbf;
   if((r=Wy::full_write(tmpbf,tstr,n_rw))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rw!=0) {
     WY_THROW( WyRet() );
   }
   if((r=Wy::full_read(tmpbf,rbuf,20))!=Wym_EBADF) {
     WY_THROW(r);
   }

   WyRegFile this_file(__FILE__,O_RDONLY);
   if((r=Wy::full_read(this_file,rbuf,16L*1024))!=Ok) {
     WY_THROW(r);
   }
   WyFileStat stt;
   if((r=this_file.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if((size_t)stt.sf_size()!=rbuf.size()) {
     WY_THROW( WyRet() );
   }

   WyStr rbuf2;
   this_file.set_pos(0);
   rbuf2._reserve(rbuf.size());
   n_rw=0;
   if((r=Wy::full_read(this_file,&rbuf2[0],rbuf2._capacity(),n_rw))!=Ok) {
     WY_THROW(r);
   }
   if(n_rw!=rbuf.size()) {
     WY_THROW( WyRet() );
   }
   rbuf2._setsize(n_rw);
   if(rbuf!=rbuf2) {
     WY_THROW( WyRet() );
   }
 }
};

static void t_error(void)
{
  // chk <<(bf,WyStr)
  {
    try {
      WyRegFile tmp;
      tmp << WyStr("kk");
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk <<(bf,WyCSeg)
  {
    try {
      WyRegFile tmp;
      tmp << WyCSeg("kk");
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk <<(bf,const char*)
  {
    try {
      WyRegFile tmp;
      tmp << (const char*)"kk";
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk <<(bf,char*)
  {
    try {
      WyRegFile tmp;
      tmp << (char*)"kk";
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk <<(bf,char)
  {
    try {
      WyRegFile tmp;
      tmp << (char)'a';
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk <<(bf,int)  (there are many, juct pickup one)
  {
    try {
      WyRegFile tmp;
      tmp << (int)1;
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk >>(bf,str)
  {
    try {
      WyRegFile tmp;
      WyStr str;
      tmp << str;
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

  // chk >>(bf,char&)
  {
    try {
      WyRegFile tmp;
      char ch('a');
      tmp << ch;
      WY_THROW( WyRet() );
    }
    catch(const WyByteFlow::Reply& e) {
      if(e!=Wym_EBADF) {
        WY_THROW( WyRet(e) );
      }
      // FALLTHROUGH
    };
  }

};

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&,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;
    if((r=Wy::_scanum(fidx,fidx,txt))!=Wym_ENOENT) {
      WY_THROW( WyRet() );
    }
    if(fidx!=100) {
      WY_THROW( WyRet() );
    }

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

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

void ck_uty(void)
{
 t1();
 t_error();
 t_scanum();
};