ck_byteflow.cpp

一个不错

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

#include "wybyteflow.h"
#include "wy_atdestroy.h"
#include "wy__cfunc.h"
#include <unistd.h>    // for ::pipe(..)
#include <iostream>

#if WYSYSFILE_VERSION!=31
#error Test code is for WYSYSFILE_VERSION 31
#endif

void ck_byteflow(void);

#ifdef WY_DEBUG
static int initial_fdcnt=0;
#endif

// Assert sysf is default
//
static void assert_default(const WyByteFlow& sysf) throw(WyRet)
{
 WyRet r;

 if(sysf.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(sysf.fh().is_default()==false) {
   WY_THROW( WyRet() );
 }

 // chk fh()
 if(sysf.fh()!=WyFileHandle()) {
   WY_THROW( WyRet() );
 }

 // stat
 {
   WyFileStat stt;
   if((r=sysf.stat(stt))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(stt.is_default()==false) {
     WY_THROW( WyRet() );
   }
 }

 if(sysf.wy_fd()!=WY__DEFAULT_FD) {
   WY_THROW( WyRet() );
 }
 if(sysf.ftype()!=0) {
   WY_THROW( WyRet() );
 }
};

// Assert f1,f2 refers to the same systerm file
//
template<typename Dev1, typename Dev2>
static void assert_same_sysf(const Dev1& f1,const Dev2& f2)
{
 if(f1.is_default()&&f2.is_default()) {
   return;
 }
 WyRet r;
 WyFileStat stt1,stt2;
 if((r=f1.stat(stt1))!=Ok) {
   WY_THROW( WyRet() );
 }
 if((r=f2.stat(stt2))!=Ok) {
   WY_THROW( WyRet() );
 }
 if(stt1.sf_ino()!=stt2.sf_ino()) {
   WY_THROW( WyRet() );
 }
 if(stt1.sf_dev()!=stt2.sf_dev()) {
   WY_THROW( WyRet() );
 }
};

#define CHK_DEFAULT(p)\
    try { assert_default(p); } catch(...) { WY_THROW( WyRet()); }
#define CHK_SAME_SYSF(p1,p2)\
    try { assert_same_sysf(p1,p2); } catch(...) { WY_THROW( WyRet()); }

static void exaust_cpy_ctor(const WyByteFlow& sysf)
{
 WyByteFlow tmp(sysf);
 exaust_cpy_ctor(sysf);   // recursive until failure
};

static void exaust_cpy_ctor(const WySysFile& sysf)
{
 WyByteFlow tmp(sysf);
 exaust_cpy_ctor(sysf);   // recursive until failure
};

static WyRet exaust_reset(const WyByteFlow& sysf) throw()
{
 WyByteFlow tmp;
 WyRet r( tmp.reset(sysf) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 return exaust_reset(sysf);   // recursive until failure
};

static WyRet exaust_reset(const WySysFile& sysf) throw()
{
 WyByteFlow tmp;
 WyRet r( tmp.reset(sysf) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 return exaust_reset(sysf);   // recursive until failure
};

// WyByteFlow ctor/reset stuff
//
void ck_byteflow_1(void)
{
  {
   if(Wy::cin.wy_is_std_fd()==false) {
     WY_THROW( WyRet() );
   }
   if(Wy::cout.wy_is_std_fd()==false) {
     WY_THROW( WyRet() );
   }
   if(Wy::cerr.wy_is_std_fd()==false) {
     WY_THROW( WyRet() );
   }
  }

 const WyFileHandle HSrc0(STDIN_FILENO);
 const WyFileHandle HSrc1(STDOUT_FILENO);
 const WyFileHandle H0;
 WyRet r;
 WyByteFlow tmp;
 CHK_DEFAULT(tmp);

 if(tmp.wy_is_std_fd()==true) {
   WY_THROW( WyRet() );
 }

   // ctor()/reset()
   {
    WyByteFlow tmp1;
    WyByteFlow tmp2(tmp1);
    CHK_DEFAULT(tmp1);
    CHK_DEFAULT(tmp2);
    if((r=tmp1.reset(tmp2))!=Ok) {
      WY_THROW(r);
    }
    if((r=tmp2.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp1);
    CHK_DEFAULT(tmp2);
   }

 try {
   // ctor(WyFileHanlde)/(const WyByteFlow&)
   {
    WyByteFlow tmp_def(H0);
    CHK_DEFAULT(tmp_def);

    WyByteFlow tmp0( HSrc0 );
    CHK_SAME_SYSF(tmp0, HSrc0 );
    if(tmp0.fh()==HSrc0) {
      WY_THROW( WyRet() );
    }
    if(tmp0.ftype()==0) {
      WY_THROW( WyRet() );
    }
  
    WyByteFlow tmp1( HSrc1 );
    CHK_SAME_SYSF(tmp1, HSrc1 );
    if(tmp1.fh()==HSrc1) {
      WY_THROW( WyRet() );
    }
    if(tmp1.ftype()==0) {
      WY_THROW( WyRet() );
    }
  
    WyByteFlow ctmp_def(tmp_def);
    CHK_DEFAULT(ctmp_def);

    WyByteFlow ctmp0(tmp0);
    CHK_SAME_SYSF(tmp0,ctmp0);
    if(tmp0.fh()==ctmp0.fh()) {
      WY_THROW( WyRet() );
    }
  
    WyByteFlow ctmp1(tmp1);
    CHK_SAME_SYSF(tmp1,ctmp1);
    if(tmp1.fh()==ctmp1.fh()) {
      WY_THROW( WyRet() );
    }
   }

   // ctor(const WySysFile&)
   {
     WySysFile tmp_sysf( HSrc1 );
     WyByteFlow tmp0(tmp_sysf);
     CHK_SAME_SYSF(tmp0,tmp_sysf.fh());
   }

   // ctor(const char*,int)/(const WyStr&,int)
   {
     WyByteFlow tmp1(__FILE__,O_RDONLY);
     WyByteFlow tmp2(WyStr(__FILE__),O_RDONLY);
     CHK_SAME_SYSF(tmp1,tmp2);
     if(tmp1.ftype()!=S_IFREG) {
       WY_THROW( WyRet() );
     }
     if(tmp2.ftype()!=S_IFREG) {
       WY_THROW( WyRet() );
     }
   }

   // chk reset()
   {
    WyByteFlow tmp;
    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);

    WyByteFlow tmp2(HSrc1);
    CHK_SAME_SYSF(tmp2,HSrc1);
    if((r=tmp2.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp2);
   }

   // chk reset(..)
   {
    WyByteFlow tmp;
  
    CHK_DEFAULT(tmp);
    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
  
    if((r=tmp.reset(tmp))!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
  
    if((r=tmp.reset(WyFileHandle()))!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
    if((r=tmp.reset(HSrc0))!=Ok) {
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,HSrc0);
    if(tmp.ftype()==0) {
      WY_THROW( WyRet() );
    }
    if((r=tmp.reset(tmp))!=Ok) {   // self-op
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,HSrc0);
    if(tmp.ftype()==0) {
      WY_THROW( WyRet() );
    }
    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
  
    //
    WyByteFlow S0(HSrc0);
    WyByteFlow S1(HSrc1);
    CHK_SAME_SYSF(S0,HSrc0);
    CHK_SAME_SYSF(S1,HSrc1);
    if((r=tmp.reset(S0))!=Ok) {  // default->S0
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S0);
    if((r=tmp.reset(S1))!=Ok) {  // S0->S1
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S1);
    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
  
    if((r=tmp.reset(S0.fh()))!=Ok) { // default->S0.fh()
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S0);
    if(tmp.ftype()==0) {
      WY_THROW( WyRet() );
    }
    if((r=tmp.reset(S1.fh()))!=Ok) {  // S0->S1.fh()
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S1);
    if(tmp.ftype()==0) {
      WY_THROW( WyRet() );
    }
    if((r=tmp.reset(S1.fh()))!=Ok) {  // S1->S1.fh()
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S1);
    if((r=tmp.reset(S1))!=Ok) {  // S1->S1
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S1);
    if((r=tmp.reset(tmp))!=Ok) {  // reset self
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp,S1);

    if((r=tmp.reset())!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(tmp);
   }

   // chk reset(const WySysFile&)
   {
     WySysFile tmp_sysf( HSrc1 );
     WyByteFlow tmp0;
     CHK_DEFAULT(tmp0);
     if((r=tmp0.reset(tmp_sysf))!=Ok) {
       WY_THROW(r);
     }
     CHK_SAME_SYSF(tmp0,tmp_sysf.fh());
     if(tmp0.ftype()==0) {
       WY_THROW( WyRet() );
     }
     // reset again
     if((r=tmp0.reset(tmp_sysf))!=Ok) {
       WY_THROW(r);
     }
     CHK_SAME_SYSF(tmp0,tmp_sysf.fh());
     if(tmp0.ftype()==0) {
       WY_THROW( WyRet() );
     }
     // reset self
     if((r=tmp0.reset(tmp0))!=Ok) {
       WY_THROW(r);
     }
     CHK_SAME_SYSF(tmp0,tmp_sysf.fh());
     if(tmp0.ftype()==0) {
       WY_THROW( WyRet() );
     }
   }

   // chk reset(const char*,int)/reset(const WyStr&,int)
   {
    WyByteFlow tmp1,tmp2;
    if((r=tmp1.reset(__FILE__,O_RDONLY))!=Ok) {
      WY_THROW(r);
    }
    if((r=tmp2.reset(WyStr(__FILE__),O_RDONLY))!=Ok) {
      WY_THROW(r);
    }
    CHK_SAME_SYSF(tmp1,tmp2);
     if(tmp1.ftype()!=S_IFREG) {
       WY_THROW( WyRet() );
     }
     if(tmp2.ftype()!=S_IFREG) {
       WY_THROW( WyRet() );
     }
   }
  
   // chk _swap(WyByteFlow&)
   {
    WyByteFlow S0(HSrc0);
    WyByteFlow S1(HSrc1);
    const WyFileHandle Fh0(S0.fh()), Fh1(S1.fh());
    CHK_SAME_SYSF(S0,HSrc0);
    CHK_SAME_SYSF(S1,HSrc1);
    r=S0._swap(S1);
    if(r!=Ok) {
      WY_THROW(r);
    }
    CHK_SAME_SYSF(S0,HSrc1);
    CHK_SAME_SYSF(S1,HSrc0);
    if(S0.fh()!=Fh1) {
      WY_THROW(r);
    }
    if(S1.fh()!=Fh0) {
      WY_THROW(r);
    }
  
    r=S1._swap(S0);
    if(r!=Ok) {
      WY_THROW(r);
    }
    if(S0.fh()!=Fh0) {
      WY_THROW(r);
    }
    if(S1.fh()!=Fh1) {
      WY_THROW(r);
    }
   }

   // chk _alloc
   {
    WyByteFlow tmp;
    WyByteFlow* p= tmp._alloc(r);
    if(r!=Ok) {
      WY_THROW(r);
    }
    if(p==0) {
      WY_THROW( WyRet() );
    }
    Wy_AtDestroy<void,WyByteFlow*> rrid(Wy::_delete_one,p);
    CHK_DEFAULT(*p);
    if((r=tmp._swap(*p))!=Ok) {
      WY_THROW(r);
    }
    CHK_DEFAULT(*p);
    CHK_DEFAULT(tmp);

    {
      class T : public WyByteFlow {
      } tmp;
      WyByteFlow* p=tmp._alloc(r);
      if(r!=Wym_ENOSYS) {
        if(r==Ok) {
          delete p;
        }
        WY_THROW(r);
      }
    }
   }

   // chk _fsync/_fdatasync/_tcdrain/_isatty
   {
    WyByteFlow tmp;
    if((r=tmp._fsync())!=Wym_EBADF) {
      WY_THROW(r);
    }
    if((r=tmp._fdatasync())!=Wym_EBADF) {
      WY_THROW(r);
    }
    if((r=tmp._tcdrain())==Ok) {
      WY_THROW(r);
    }
    if(tmp._isatty()==true) {
      WY_THROW( WyRet() );
    }

    WyByteFlow S0(HSrc0);
    if(S0._isatty()) {
      if((r=S0._fsync())!=Wym_EINVAL) {
        WY_THROW(r);
      }
      if((r=S0._fdatasync())!=Wym_EINVAL) {
        WY_THROW(r);
      }
      if((r=S0._tcdrain())!=Ok) {
        WY_THROW(r);
      }
    }
   }

   // chk ctor failure (WyFileHandle)
   {
     try {
       WyByteFlow tmp( WyFileHandle(-2) );
       WY_THROW( WyRet() );   // assume no fd is currently -2
     }
     catch(const WyByteFlow::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH