ck_chrfile.cpp

一个不错

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

   Check WyChrFile public members

   Note: Test data files should exist in the working directory
         Files may be created in the working directory and unlinked
*/

#include "wychrfile.h"
#include "wy_uty.h"
#include "wy_atdestroy.h"
#include <new>

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

void ck_chrfile(bool);

#ifdef WY_DEBUG
static int initial_fdcnt=0;
#endif

static bool exaustfd_flag=true;
static const int NoSuchFd=-2;
static const char NoSuchPathName[]="No.Such.Pathname.tmp";
static const WyStr RefFileName("/dev/tty");

// Assert ff is default
//
static void assert_default(const WyChrFile& ff)
{
 WyRet r;
 if(ff.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()==false) {
   WY_THROW( WyRet() );
 }

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

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

 // The following are non-const, so construct ff from tmpf for checks
 //
 WyChrFile tmpf(ff);

 // read(void*,..)
 {
  char buf[2];
  size_t n_rd=sizeof(buf);
  if((r=tmpf.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

 // read(WyStr&)
 {
  WyStr buf;
  size_t n_rd=5;
  if((r=tmpf.read(buf,size_t(5),n_rd))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
  if(buf.is_default()==false) {
    WY_THROW( WyRet() );
  }
 }

 // write
 {
  char buf[2]={5,6};
  size_t n_wr=sizeof(buf);
  if((r=tmpf.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_wr!=0) {
    WY_THROW( WyRet() );
  }
  if((buf[0]!=5)||(buf[1]!=6)) {
    WY_THROW( WyRet() );
  }
  WyStr str("ab");
  if((r=tmpf.write(str,n_wr))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_wr!=0) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.write( WyCSeg(str.cseg()),n_wr))!=Wym_EBADF) {
    WY_THROW(r);
  }
  if(n_wr!=0) {
    WY_THROW( WyRet() );
  }
 }

 //  _tcdrain,_isatty
 if((r=tmpf._tcdrain())!=Wym_EBADF) {
   WY_THROW(r);
 }

 // reset(const WyStr&,int)
 if((r=tmpf.reset(WyStr(NoSuchPathName),O_RDONLY))!=Wym_ENOENT) {
   WY_THROW(r);
 }
 if(tmpf.is_default()==false) {
   WY_THROW( WyRet() );
 }

 // reset(const char*,int)
 if((r=tmpf.reset(NoSuchPathName,O_RDONLY))!=Wym_ENOENT) {
   WY_THROW(r);
 }
 if(tmpf.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if((r=tmpf.reset("/dev/zero",O_RDONLY))!=Ok) {
   WY_THROW(r);
 }
 if((r=tmpf.reset())!=Ok) {
   WY_THROW(r);
 }

 // reset(WyFileHandle)
 {
  if((r=tmpf.reset(WyFileHandle()))!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()==false) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.reset(tmpf))!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()==false) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.reset(ff))!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()==false) {
    WY_THROW( WyRet() );
  }
 }

 // reset()
 if((r=tmpf.reset())!=Ok) {
   WY_THROW(r);
 }

 if((r=tmpf.reset(ff))!=Ok) {
   WY_THROW(r);
 }
 if(tmpf.is_default()==false) {
   WY_THROW( WyRet() );
 }

 if(static_cast<const WyByteFlow&>(ff).ftype()!=0) {
   WY_THROW( WyRet() );
 }
};

// Assert ff is not default
//
static void assert_not_default(const WyChrFile& ff)
{
 WyRet r;

 WyChrFile NObj;     // non-default object for the check
 if(NObj.is_default()==false) {
   WY_THROW( WyRet() );
 }
 if((r=NObj.reset(RefFileName,O_RDONLY))!=Ok) {
   WY_THROW(r);
 }
 if(NObj.is_default()) {
   WY_THROW( WyRet() );
 }

 if(ff.is_default()) {
   WY_THROW( WyRet() );
 }
 if(ff.fh().is_default()) {
   WY_THROW( WyRet() );
 }

 // stat
 {
   WyFileStat stt;
   if((r=ff.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
 }

 // The following are non-const, so construct ff to tmpf for checks
 //
 {
  WyChrFile tmpf(NObj);

  if(tmpf.is_default()) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.reset())!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()==false) {
    WY_THROW( WyRet() );
  }
 }

 // read (char)
 {
  WyChrFile tmpf(NObj);
  if(tmpf.is_default()) {
    WY_THROW( WyRet() );
  }
  char buf[2];
  size_t n_rd=sizeof(buf);
  if((r=tmpf.read(buf,size_t(0),n_rd))!=Ok) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

 // read (WyStr)
 {
  WyChrFile tmpf(NObj);
  if(tmpf.is_default()) {
    WY_THROW( WyRet() );
  }
  WyStr buf;
  size_t n_rd=5;
  if((r=tmpf.read(buf,size_t(0),n_rd))!=Ok) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

 // reset(WyFileHandle)
 {
  WyChrFile tmpf(NObj);
  if(tmpf.is_default()) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.reset(ff))!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()) {
    WY_THROW( WyRet() );
  }
  if((r=tmpf.reset(WyFileHandle()))!=Ok) {
    WY_THROW(r);
  }
  if(tmpf.is_default()==false) {
    WY_THROW( WyRet() );
  }
 }

 if(static_cast<const WyByteFlow&>(ff).ftype()!=S_IFCHR) {
   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()) {
   assert_default(f1);
 } else {
   assert_not_default(f1);
 }

 if(f2.is_default()) {
   assert_default(f2);
 } else {
   assert_not_default(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_NOT_DEFAULT(p)\
    try { assert_not_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 WySysFile& chrf)
{
 WyChrFile tmp(chrf);
 exaust_cpy_ctor(chrf);   // recursive until failure
};

static void exaust_cpy_ctor(const WyChrFile& chrf)
{
 WyChrFile tmp(chrf);
 exaust_cpy_ctor(chrf);   // recursive until failure
};

//
// Setup the test 
//
static void setup_test(void)
{
};

//
// Undo setup_test
//
static void close_test(void)
{
};

//
// Check basic operations on default object
//
static void t1(void)
{
 WyRet r;

 WyChrFile NObj;     // non-default object for test as argument
 CHK_DEFAULT(NObj);
 if((r=NObj.reset(RefFileName,O_RDONLY))!=Ok) {
   WY_THROW(r);
 }
 CHK_NOT_DEFAULT(NObj);
 
 // stat
 {
   WyFileStat stt;
   if((r=NObj.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
 }

 // WyChrFile(),WyChrFile(const WyChrFile&),WyChrFile(const WyByteFlow&)
 {
   WyChrFile tmp0;
   WyChrFile tmp1(tmp0);
   CHK_DEFAULT(tmp0);
   CHK_DEFAULT(tmp1);

   WyChrFile tmp2(NObj);
   CHK_NOT_DEFAULT(tmp2);
   if(tmp2.fh()==NObj.fh()) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp2,NObj);

   WyChrFile tmp3(static_cast<WyByteFlow&>(tmp0));
   CHK_SAME_SYSF(tmp3,tmp0);
   WyChrFile tmp4(static_cast<WyByteFlow&>(NObj));
   CHK_SAME_SYSF(tmp4,NObj);
   WyChrFile tmp5(NObj.fh());
   CHK_SAME_SYSF(tmp5,NObj);
 }

 // WyChrFile(const WyStr&,int) WyChrFile(const char*,int)
 {
   WyChrFile tmp1(RefFileName,O_RDONLY);  // same as NObj
   CHK_SAME_SYSF(tmp1,NObj);

   WyChrFile tmp2(RefFileName.c_str(),O_RDONLY);  // same as NObj
   CHK_SAME_SYSF(tmp2,tmp1);
 }

 // WyChrFile(WyFileHandle)
 {
   WyChrFile tmp( WyFileHandle(STDERR_FILENO) );
   CHK_NOT_DEFAULT(tmp);
   WyFileStat stt;
   if((r=tmp.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }
   if(tmp.fh().fd()==STDERR_FILENO) {
     WY_THROW( WyRet() );
   }
 }

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

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

   WyChrFile tmp2(NObj);
   CHK_NOT_DEFAULT(tmp2);
   if((r=tmp2.reset())!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp2);
 }

 // reset(const WyByteFlow&)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(static_cast<WyByteFlow&>(NObj)))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
   if((r=tmp.reset(NObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
   const WyFileHandle TmpFh( tmp.fh() );
   if((r=tmp.reset(tmp))!=Ok) {
     WY_THROW(r);
   }
   if(tmp.fh()!=TmpFh) {
     // Ok either way
   }

   tmp.reset();
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyByteFlow()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(Wy::cin))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset(WyChrFile()))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);

 }

 // reset(const char*,int)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(RefFileName.c_str(),O_RDONLY))!=Ok) {  // same as NObj
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

 // reset(const WyStr&,int)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(RefFileName,O_RDONLY))!=Ok) {  // same as NObj
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
 }

 // reset(WyFileHandle)
 {
   WyChrFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(WyFileHandle(STDERR_FILENO)))!=Ok) {  // same as NObj
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
   WyFileStat stt;
   if((r=tmp.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_chr()==false) {
     WY_THROW( WyRet() );
   }

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

   if((r=tmp.reset(tmp))!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset(NObj.fh()))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,NObj);
   const WyFileHandle TmpFh( tmp.fh() );
   if((r=tmp.reset(tmp))!=Ok) {
     WY_THROW(r);
   }
   if(tmp.fh()!=TmpFh) {
     // Ok either way
   }
 }

 // _swap
 {
  WyChrFile tmp0(NObj),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_SAME_SYSF(tmp0,NObj);

  if((r=tmp1._swap(tmp2))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);

  if((r=tmp1._swap(tmp0))!=Ok) {
    WY_THROW(r);