ck_regfile.cpp

一个不错

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

   Check WyRegFile public members

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

#include "wyregfile.h"
#include "wy_uty.h"
#include "wy_atdestroy.h"
#include "chk_data.h"
#include <stdlib.h>
#include <unistd.h>
#include <new>

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

void ck_regfile(bool,const char*);

#ifdef WY_DEBUG
static int initial_fdcnt=0;
#endif

static const WyStr Tmp_Name("tmp.chk_tobjile-open_tmpfile.tmp");
static bool exaustfd_flag=true;
static WyStr arg_rtfile;    // filename for read test file

// Assert regf is default
//
static void assert_default(const WyRegFile& regf)
{
 WyRet r;

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

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

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

 // chk pos(0)
 if(regf.pos()!=0) {
   WY_THROW( WyRet() );
 }
 if(static_cast<const WyByteFlow&>(regf).ftype()!=0) {
   WY_THROW( WyRet() );
 }
};

static void assert_not_default(const WyRegFile& regf)
{
 WyRet r;

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

 // stat
 {
   WyFileStat stt;
   if((r=regf.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_reg()==false) {
     WY_THROW( WyRet() );
   }
 }
 if(static_cast<const WyByteFlow&>(regf).ftype()!=S_IFREG) {
   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& sysf)
{
 WyRegFile tmp(sysf);
 exaust_cpy_ctor(sysf);   // recursive until failure
};

// Check basic operations on default object
//
static void t1(void)
{
 WyRegFile EmptyFile(TestFile_Empty,O_RDONLY);

 WyRet r;

 // Prepare
 //
 CHK_NOT_DEFAULT(EmptyFile);

 // WyRegFile()/WyRegFile(const WyRegFile&)/(const WyByteFlow&)
 {
   WyRegFile tobj;
   WyRegFile tmp1(tobj);
   CHK_DEFAULT(tobj);
   CHK_DEFAULT(tmp1);

   WyRegFile tmp2(EmptyFile);
   CHK_NOT_DEFAULT(tmp2);
   if(tmp2.fh()==EmptyFile.fh()) {
     WY_THROW( WyRet() );
   }
   CHK_SAME_SYSF(tmp2,EmptyFile);
   if(tmp2.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }

   WyRegFile tmp3(static_cast<WyByteFlow&>(EmptyFile));
   CHK_SAME_SYSF(tmp3,EmptyFile);

   WyRegFile tmp4(static_cast<WyByteFlow&>(tobj));
   CHK_SAME_SYSF(tmp4,tobj);
 }

 // WyRegFile(const char*,int)
 {
   WyRegFile tmp(TestFile_Empty.c_str(),O_RDONLY); // same as EmptyFile
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
 }

 // WyRegFile(const WyStr&,int)
 {
   WyRegFile tmp(TestFile_Empty,O_RDONLY); // same as EmptyFile
   CHK_NOT_DEFAULT(tmp);
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
 }

 // WyRegFile(WyFileHandle)
 {
   WyFileHandle dfh;
   WyRegFile tmp1( dfh );
   CHK_DEFAULT(tmp1);

   WyRegFile tmp2( EmptyFile.fh() ); // same as EmptyFile
   CHK_NOT_DEFAULT(tmp2);
   CHK_SAME_SYSF(tmp2,EmptyFile);
   if(tmp2.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
 }

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

 // reset(const WyByteFlow&)
 {
   WyRegFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(EmptyFile))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
   if(tmp.reset()!=Ok) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(EmptyFile)))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }

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

 // reset(const char*,int)
 {
   WyRegFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(TestFile_Empty.c_str(),O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
 }
 
 // reset(const WyStr&,int)
 {
   WyRegFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(TestFile_Empty,O_RDONLY))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }
 }
 
 // reset(WyFileHandle)
 {
   WyRegFile tmp;
   CHK_DEFAULT(tmp);
   if((r=tmp.reset( EmptyFile.fh() ))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,EmptyFile);
   if(tmp.pos()!=EmptyFile.pos()) {
     WY_THROW( WyRet() );
   }

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

 // read
 {
   WyRegFile tobj;
   char buf[2]={-1,-1};
   size_t n_rd=5;   // anything not zero
   CHK_DEFAULT(tobj);
   if((r=tobj.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_rd=5;
   if((r=EmptyFile.read(buf,sizeof(buf),n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(EmptyFile.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // read WyStr
 {
   WyRegFile tobj;
   WyStr buf;
   size_t n_rd=5;   // anything not zero
   CHK_DEFAULT(tobj);
   if((r=tobj.read(buf,size_t(2),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(buf.is_default()==false) {
     WY_THROW( WyRet() );
   }
   n_rd=5;
   if((r=EmptyFile.read(buf,size_t(2),n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(EmptyFile.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // write
 {
   WyRegFile tobj;
   char buf[2]={-1,-1};
   size_t n_wr=5;   // anything not zero
   CHK_DEFAULT(tobj);
   if((r=tobj.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=5;
   CHK_DEFAULT(tobj);
   if((r=tobj.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
   if((r=tobj.write(WyStr( WyCSeg(buf,sizeof(buf)) ),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // fdatasync,fsync
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if((r=tobj.fdatasync())!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tobj.fsync())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tobj);
 }

 // pos()/set_pos()
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if(tobj.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
   tobj.set_pos(100);
   if(tobj.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // set_pos_end()
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if((r=tobj.seek_end())!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tobj);
 }

 // _read_till(1)
 {
   WyRegFile tobj;
   char buf[2]={-1,-1};
   size_t n_rd=5;   // anything not zero 
   CHK_DEFAULT(tobj);
   if((r=tobj._read_till(buf,sizeof(buf),n_rd,'\n'))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   n_rd=5;
   if((r=EmptyFile._read_till(buf,sizeof(buf),n_rd,'\n'))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(EmptyFile.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // _read_till(2)
 {
   WyRegFile tobj;
   WyStr buf("a");
   size_t n_rd=5;   // anything not zero
   CHK_DEFAULT(tobj);
   if((r=tobj._read_till(buf,size_t(1),n_rd,'\n'))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW(r);
   }
   if(buf!="a") {
     WY_THROW(r);
   }
   if((r=EmptyFile._read_till(buf,size_t(0),n_rd,'\n'))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(buf!="a") {
     WY_THROW(r);
   }

   n_rd=5;   // pre-set for test overwrite
   if((r=EmptyFile._read_till(buf,size_t(1),n_rd,'\n'))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if(buf!="a") {
     WY_THROW(r);
   }
   if(EmptyFile.pos()!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tobj);
 }

 // resize
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if((r=tobj.resize(1))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tobj);
 }

 // reset(const char*,int)
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if((r=tobj.reset("tmp_use.del_me",0))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tobj);
 }

 // reset(const WyStr&,int)
 {
   WyRegFile tobj;
   CHK_DEFAULT(tobj);
   if((r=tobj.reset(WyStr("tmp_use.del_me"),0))!=Wym_ENOENT) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tobj);
 }

 // create_tmpfile
 //
 {
   WyRegFile tobj;
   WyStr tmp_name(Tmp_Name);
   CHK_DEFAULT(tobj);
   if((r=WyRegFile::create_tmpfile(tobj,tmp_name))!=Ok) {
     WY_THROW(r);
   }
   Wy_AtDestroy<WyRet,const WyStr&> rrid(Wy::unlink,tmp_name);
   CHK_NOT_DEFAULT(tobj);
   if(tmp_name.size()!=Tmp_Name.size()+6) {
     WY_THROW( WyRet() );
   }
   if(::access(tmp_name.c_str(),F_OK)!=0) {
     r=WyReply(errno); WY_THROW(r);
   }
 }

 // _swap
 {
  WyRegFile tmp0(EmptyFile),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(EmptyFile);

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

  if((r=tmp1._swap(tmp0))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);
  CHK_SAME_SYSF(tmp1,EmptyFile);

  if((r=tmp0._swap(tmp1))!=Ok) {
    WY_THROW(r);
  }
  CHK_DEFAULT(tmp1);
  CHK_NOT_DEFAULT(tmp0);
  CHK_SAME_SYSF(tmp0,EmptyFile);

  WySysFile abc;
  if((r=abc._swap(tmp1))!=Wym_EBADTYPE) {
    WY_THROW(r);
  }
 }

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

// Check basic operations on non-default object
//
static void t2(void)
{
 WyRegFile EmptyFile(TestFile_Empty,O_RDONLY);
 WyRegFile TFile1A(TestFile_1A,O_RDONLY);
 WyRegFile TFile2A(TestFile_2A,O_RDONLY);
 WyRet r;

 CHK_NOT_DEFAULT(EmptyFile);
 CHK_NOT_DEFAULT(TFile1A);
 CHK_NOT_DEFAULT(TFile2A);

 // chk EmptyFile
 //
 if(EmptyFile.pos()!=0) {
   WY_THROW( WyRet() );
 }
 if(EmptyFile.fh().is_default()) {
   WY_THROW( WyRet() );
 }

 // stat EmptyFile
 {
   WyFileStat stt;
   if((r=EmptyFile.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_default()) {
     WY_THROW( WyRet() );
   }
   if(stt.is_reg()==false) {
     WY_THROW( WyRet() );
   }
   if(stt.sf_size()!=0) {
     WY_THROW( WyRet() );
   }
 }

 // chk TFile1A
 //
 if(TFile1A.pos()!=0) {
   WY_THROW( WyRet() );
 }
 if(TFile1A.fh().is_default()) {
   WY_THROW( WyRet() );
 }

 // stat TFile1A
 {
   WyFileStat stt;
   if((r=TFile1A.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_default()) {
     WY_THROW( WyRet() );