chk_filestat.cpp

一个不错

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

   Basic test of WyFileStat

   Build: make chk_filestat
*/

#include "wyfilestat.h"
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include "wystr.h"
#include <iostream>

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

//
// Check for default object
//
static bool chk_default(const WyFileStat& stt)
{
 if(stt.is_default()==false) {
   return(false);
 }
 if(stt.sf_mode()!=mode_t()) {
   return(false);
 }
 if(stt.sf_ino()!=ino_t()) {
   return(false);
 }
 if(stt.sf_dev()!=dev_t()) {
   return(false);
 }
 if(stt.sf_nlink()!=nlink_t()) {
   return(false);
 }
 if(stt.sf_uid()!=uid_t()) {
   return(false);
 }
 if(stt.sf_gid()!=gid_t()) {
   return(false);
 }
 if(stt.sf_size()!=off_t()) {
   return(false);
 }
 if(stt.sf_atime()!=Wy_Second()) {
   return(false);
 }
 if(stt.sf_ctime()!=Wy_Second()) {
   return(false);
 }
 if(stt.sf_mtime()!=Wy_Second()) {
   return(false);
 }

 if(stt.sf_rdev()!=dev_t()) {
   return(false);
 }
 if(stt.sf_blksize()!=blksize_t()) {
   return(false);
 }
 if(stt.sf_blocks()!=blkcnt_t()) {
   return(false);
 }

 if(stt.is_dir()) {
   return(false);
 }
 if(stt.is_chr()) {
   return(false);
 }
 if(stt.is_blk()) {
   return(false);
 }
 if(stt.is_reg()) {
   return(false);
 }
 if(stt.is_fifo()) {
   return(false);
 }
 if(stt.is_lnk()) {
   return(false);
 }
 if(stt.is_sock()) {
   return(false);
 }
 if(const_cast<WyFileStat&>(stt).wy_stat_ptr()==0) {
   WY_THROW( WyRet() );
 }
 if(stt==WyFileStat()) {
 } else {
   WY_THROW( WyRet() );
 }
 return(true);
};

static bool chk_equ(const WyFileStat& stt1,const WyFileStat& stt2)
{
 if(stt1.is_default()!=stt2.is_default()) {
   return(false);
 }
 if(stt1.sf_mode()!=stt2.sf_mode()) {
   return(false);
 }
 if(stt1.sf_ino()!=stt2.sf_ino()) {
   return(false);
 }
 if(stt1.sf_dev()!=stt2.sf_dev()) {
   return(false);
 }
 if(stt1.sf_nlink()!=stt2.sf_nlink()) {
   return(false);
 }
 if(stt1.sf_uid()!=stt2.sf_uid()) {
   return(false);
 }
 if(stt1.sf_gid()!=stt2.sf_gid()) {
   return(false);
 }
 if(stt1.sf_size()!=stt2.sf_size()) {
   return(false);
 }
 if(stt1.sf_atime()!=stt2.sf_atime()) {
   return(false);
 }
 if(stt1.sf_ctime()!=stt2.sf_ctime()) {
   return(false);
 }
 if(stt1.sf_mtime()!=stt2.sf_mtime()) {
   return(false);
 }

 if(stt1.sf_rdev()!=stt2.sf_rdev()) {
   return(false);
 }
 if(stt1.sf_blksize()!=stt2.sf_blksize()) {
   return(false);
 }
 if(stt1.sf_blocks()!=stt2.sf_blocks()) {
   return(false);
 }

 if(stt1.is_dir()!=stt2.is_dir()) {
   return(false);
 }
 if(stt1.is_chr()!=stt2.is_chr()) {
   return(false);
 }
 if(stt1.is_blk()!=stt2.is_blk()) {
   return(false);
 }
 if(stt1.is_reg()!=stt2.is_reg()) {
   return(false);
 }
 if(stt1.is_fifo()!=stt2.is_fifo()) {
   return(false);
 }
 if(stt1.is_lnk()!=stt2.is_lnk()) {
   return(false);
 }
 if(stt1.is_sock()!=stt2.is_sock()) {
   return(false);
 }
 if((const_cast<WyFileStat&>(stt1).wy_stat_ptr()==0)||
    (const_cast<WyFileStat&>(stt2).wy_stat_ptr()==0)) {
   WY_THROW( WyRet() );
 }
 if(stt1==stt2) {
 } else {
   WY_THROW( WyRet() );
 }
 return(true);
};

#define CHK_EQU(expr1,expr2) if(chk_equ(expr1,expr2)==false) { WY_THROW( WyRet() ); };
#define CHK_NOT_EQU(expr1,expr2) if(chk_equ(expr1,expr2)==true) { WY_THROW( WyRet() ); };

#define CHK_DEFAULT(expr) if(chk_default(expr)==false) { WY_THROW( WyRet() ); };
#define CHK_NOT_DEFAULT(expr) if(chk_default(expr)==true) { WY_THROW( WyRet() ); };

static void t1(void)
{

 // Check default object
 //
 {
   WyFileStat tmp;
   CHK_DEFAULT(tmp);

   WyFileStat tmp2(tmp);
   CHK_DEFAULT(tmp2);

   tmp2.reset(tmp);
   CHK_DEFAULT(tmp2);

   tmp2.reset();
   CHK_DEFAULT(tmp2);
 }

 // Check on non-default tobj
 //
 struct stat sttcwd;
 WyFileStat tobj;
 {
   // set sttcwd with the working directory filestat
   if(::stat(".",&sttcwd)!=0) {
     WY_THROW( WyRet() );
   }
   // set tobj internal stat to sttcwd
   CHK_DEFAULT(tobj);
   *tobj.wy_stat_ptr()=sttcwd;
   CHK_NOT_DEFAULT(tobj);
 }

 // chk WyFileStat(const struct stat*)
 {
  WyFileStat tmp(sttcwd);
  if(tmp!=tobj) {
    WY_THROW( WyRet() );
  }
 }

 if(sttcwd.st_mode!=tobj.sf_mode()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_ino!=tobj.sf_ino()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_dev!=tobj.sf_dev()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_nlink!=tobj.sf_nlink()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_uid!=tobj.sf_uid()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_gid!=tobj.sf_gid()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_rdev!=tobj.sf_rdev()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_size!=tobj.sf_size()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_blksize!=tobj.sf_blksize()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_blocks!=tobj.sf_blocks()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_atime!=tobj.sf_atime()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_ctime!=tobj.sf_ctime()) {
   WY_THROW( WyRet() );
 }
 if(sttcwd.st_mtime!=tobj.sf_mtime()) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_dir()!=S_ISDIR(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_chr()!=S_ISCHR(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_blk()!=S_ISBLK(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_reg()!=S_ISREG(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_fifo()!=S_ISFIFO(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_lnk()!=S_ISLNK(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }
 if(tobj.is_sock()!=S_ISSOCK(sttcwd.st_mode)) {
   WY_THROW( WyRet() );
 }

 // Check information directly derived from the system call
 // If uid is not 0, assume it is identical to the uid of cwd (may not be right)
 //
 if(tobj.sf_uid()!=::getuid()) {
   WY_THROW( WyRet() );    // may be ok, check this to comment out
 }
 if(tobj.sf_gid()!=::getgid()) {
   WY_THROW( WyRet() );    // may be ok, check this to comment out
 }

 {
   // Test copy constructor
   WyFileStat tmp(tobj);
   CHK_NOT_DEFAULT(tmp);
   tmp.reset();
   CHK_DEFAULT(tmp);
 }

 // swap
 {
  WyFileStat NObj;
  NObj.wy_stat_ptr()->st_blocks=1;    // make non-default

  WyFileStat tmp0(NObj),tmp1,tmp2;
  CHK_NOT_DEFAULT(tmp0);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);
  CHK_NOT_DEFAULT(NObj);

  tmp1.swap(tmp2);
  CHK_DEFAULT(tmp1);
  CHK_DEFAULT(tmp2);

  tmp1.swap(tmp0);
  CHK_DEFAULT(tmp0);
  CHK_NOT_DEFAULT(tmp1);
  CHK_EQU(tmp1,NObj);

  tmp0.swap(tmp1);
  CHK_DEFAULT(tmp1);
  CHK_NOT_DEFAULT(tmp0);
  CHK_EQU(tmp0,NObj);
 }

 // reset
 {
   WyFileStat tmp;
   CHK_DEFAULT(tmp);
   tmp.reset(tobj);
   CHK_NOT_DEFAULT(tmp);
   CHK_EQU(tmp,tobj);
 }

 // chk move ctor
 {
  char buf[2*sizeof(WyFileStat)];
  ::memset(buf,0,sizeof(buf));
  WyFileStat*p=reinterpret_cast<WyFileStat*>(buf);
  new(p) WyFileStat();
  new(p+1) WyFileStat(*p,Wy::ByMove);
  if((p+1)->is_default()==false) {
    (p+1)->~WyFileStat();
    WY_THROW( WyRet() );
  }
  (p+1)->~WyFileStat();
 }
};

static void t2(void)
{
 WyRet r;
 // chk Wy::stat
 {
  WyFileStat stt;
  if((r=Wy::stat((const char*)"./",stt))!=Ok) {
    WY_THROW(r);
  }
  if(stt.is_dir()==false) {
    WY_THROW( WyRet() );
  }

  stt.reset();
  if((r=Wy::stat(WyStr("./"),stt))!=Ok) {
    WY_THROW(r);
  }
  if(stt.is_dir()==false) {
    WY_THROW( WyRet() );
  }
 }
};

#include "wy_array.h"

static void t_array(void)
{
 /*
 // chk struct struct stat
 // (simple chk)
 {
   typedef struct stat ElemType;
   Wy_Array<ElemType> tmp;
   struct stat ts;
   ts.st_dev=123;
   ts.st_ino=45;

   tmp.push_back(ts);
   if(tmp.size()!=1) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].st_dev!=ts.st_dev) {
     WY_THROW( WyRet() );
   }
   if(tmp[0].st_ino!=ts.st_ino) {
     WY_THROW( WyRet() );
   }

   tmp.push_back(ElemType());
   if(tmp.size()!=2) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].st_dev!=0) {
     WY_THROW( WyRet() );
   }
   if(tmp[1].st_ino!=0) {
     WY_THROW( WyRet() );
   }
 }*/
};

static const WyStr chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wyfilestat.h ...\n";

 if(WyStr(WyFileStat::class_name)!="WyFileStat") {
   WY_THROW( WyRet() );
 }
 t1();
 t2();
 t_array();
 std::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 std::cerr << chdr.c_str() << Wy::wrd(e).c_str() << std::endl;
 return(-1);
}
catch(const std::exception& e) {
 std::cerr << chdr.c_str() << "std::exception" << std::endl;
 return(-1);
}
catch(...) {
 std::cerr << chdr.c_str() << "unknown unwind" << std::endl;
 return(-1);
};