chk_cout.cpp

一个不错

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

   Check Wy::cout

   Build: make chk_cout

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

#include "wyterminal.h"
#include "wyregfile.h"
#include "chk_data.h"
#include <unistd.h>
#include <iostream>

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

//
// Assert f1,f2 the same systerm file
//
static void assert_same_sysf(const WyByteFlow& f1,const WyByteFlow& 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_SAME_SYSF(p1,p2)\
    try { assert_same_sysf(p1,p2); } catch(...) { throw; }

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

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

static void t1(void)
{
 WyRegFile TFile("chk_cout.cpp",O_RDONLY);
 WyRet r;

 class RAID {
      WyByteFlow _org;
   public:
     RAID(const WyByteFlow& src) : _org(src) {
        if(_org.wy_is_std_fd()==true) {
          WY_THROW( WyRet() );
        }
     };
     ~RAID() {
        Wy::cout.reset(_org);
     };
     const WyByteFlow& sysf(void) const { return _org; };
 } rrid(Wy::cout);

 CHK_SAME_SYSF(Wy::cout,rrid.sysf());
 if(Wy::cout.wy_is_std_fd()==false) {
   WY_THROW( WyRet() );
 }


 // reset(const WyByteFlow&)
 if((r=Wy::cout.reset(static_cast<const WyByteFlow&>(TFile)))!=Ok) {
   WY_THROW(r);
 }
 if(Wy::cout.fh().fd()!=STDOUT_FILENO) {
   WY_THROW( WyRet() );
 }
 CHK_SAME_SYSF(Wy::cout,TFile);
/*
 if(Wy::cout.reset(WyFileHandle(STDOUT_FILENO))!=Ok) {
   WY_THROW(r);
 }
 CHK_SAME_SYSF(Wy::cout,TFile);
 
 // reset(WyFileHandle)
 if((r=Wy::cout.reset(TFile.fh()))!=Ok) {
   WY_THROW(r);
 }
 if(Wy::cout.fh().fd()!=STDOUT_FILENO) {
   WY_THROW( WyRet() );
 }
 CHK_SAME_SYSF(Wy::cout,TFile);
*/
 // recover Wy::cout
 if(Wy::cout.is_default()==true) {
   WY_THROW( WyRet() );
 }
 if((r=Wy::cout.reset(rrid.sysf()))!=Ok) {
   WY_THROW(r);
 }
 if(Wy::cout.fh().fd()!=STDOUT_FILENO) {
   WY_THROW( WyRet() );
 }
 CHK_SAME_SYSF(Wy::cout,rrid.sysf());
 
 // _swap
 if((r=Wy::cout._swap(TFile))!=Wym_EBADTYPE) {
   WY_THROW(r);
 }

 // _alloc
 if((Wy::cout._alloc(r))!=NULL) {
   WY_THROW( WyRet() );
 }
 if(r!=Wym_ENOSYS) {
   WY_THROW(r);
 }
};

// chk reset()
//
static void t_last(void)
{
 class RAID {
     const WyByteFlow _org_std;
   public:
     RAID() : _org_std(Wy::cout) {};
     ~RAID() {
        ::dup2(_org_std.wy_fd(),STDOUT_FILENO);
      };
 } not_use_me;

 const WyRegFile TFile("chk_cout.cpp",O_RDONLY);
 WyByteFlow& STDOBJ(Wy::cout);
 WyRet r;

 if((r=STDOBJ.reset(TFile))!=Ok) {
   WY_THROW(r);
 }
 CHK_SAME_SYSF(STDOBJ,TFile);

 if((r=STDOBJ.reset(TFile.fh()))!=Ok) {
   WY_THROW(r);
 }
 CHK_SAME_SYSF(STDOBJ,TFile);

 // chk error
 if((r=STDOBJ.reset(WyFileHandle()))!=Wym_EBADF) {
   WY_THROW(r);
 }
 CHK_SAME_SYSF(STDOBJ,TFile);
 if((r=STDOBJ.reset(WyByteFlow()))!=Wym_EBADF) {
   WY_THROW(r);
 }
 CHK_SAME_SYSF(STDOBJ,TFile);

 try {
   STDOBJ.reset();
   WY_THROW( WyRet() );
 }
 catch(const WyByteFlow::Reply& e) {
   WY_THROW( WyRet(e) );
 }
 catch(const WyRet& e) {
   if(e!=Wym_EBADF) {
     WY_THROW( WyRet(e) );
   }
 };
 CHK_SAME_SYSF(STDOBJ,TFile);
};

//
// Write Wy::cout as a regular file
//
static void t_cout_reg(void)
{
  // std::cout is being testing, use std::cerr for message
  std::cerr<< "Wy::cout is a regular file\n" << std::flush;

  WyRet r;
  WyRegFile regf;

  if((r=regf.reset(Wy::cout.fh()))!=Ok) {
     WY_THROW(r);
  }
  // write Wy::cout file
  const char buf[]="\"This string is sent to Wy::cout(reg)\"\n";
  size_t n_wr;
  if((r=regf.write(buf,sizeof(buf),n_wr))!=Ok) {
    WY_THROW(r);
  }
  if(n_wr!=sizeof(buf)) {
    WY_THROW( WyRet() );
  }
  if((r=regf.fdatasync())!=Ok) {
    WY_THROW(r);
  }
};

//
// Read Wy::cout as a character file
//
static void t_cout_chr(void)
{
   // std::cout is being testing, use std::cerr for message
   std::cerr << "Wy::cout is a character file\n";
   WyRet r;
   WyChrFile chrf;

   if((r=chrf.reset(Wy::cout.fh()))!=Ok) {
     WY_THROW(r);
   }

   // Write
   const char buf[]="\"This string is sent to Wy::cout(chr)\"\n";
   size_t n_wr;
   if((r=chrf.write(buf,sizeof(buf),n_wr))!=Ok) {
     WY_THROW(r);
   }
   if(n_wr!=sizeof(buf)) {
      WY_THROW( WyRet() );
   }
};

//
// Check Wy::cout
//
static void t_cout(void)
{
 WyRet r;

 // startup condition check
 if(Wy::cout.is_default()) {
   WY_THROW( WyRet() );
 }
 if(Wy::cout.fh().fd()!=STDOUT_FILENO) {
   WY_THROW( WyRet() );
 }

 // stat
 WyFileStat stt;
 if((r=Wy::cout.stat(stt))!=Ok) {
   WY_THROW(r);
 }
 if(stt.is_chr()) {
   t_cout_chr();
   return;
 }
 if(stt.is_reg()) {
   t_cout_reg();
   return;
 }
 WY_THROW( WyRet() );  // neither chr nor reg file
};

static void t_exception(void)
{
 //
 // Test copy constructor exception
 //
 try {
 }
 catch(...) {
   throw;
 };

 //
 // Test destructor exception
 //
 {
 }
};

static WyStr chdr("+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 try {
   // std::cout is being testing, use std::cerr for message
   std::cerr << "Checking Wy::cout ...\n";

   setup_test();
   t1();
   t_cout();
   t_exception();
   close_test();
   t_last();

   // std::cout is being testing, use std::cerr for message
   std::cerr << "Checked Ok\n";
 }
 catch(...) {
   close_test();
   throw;
 }
 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);
};