chk_poly.cpp

一个不错

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

   Build: make chk_poly

   For the moment checking ctor(const WyByteFlow&) only 
   (since implement calls reset(..))
*/

#include "wyret.h"
#include "wyregfile.h"
#include "wychrfile.h"
#include "wyfifofile.h"
#include "wysockfile.h"
#include "wyterminal.h"
#include <iostream>
#include "chk_data.h"

// Assert sysf is default
//
static void assert_default(const WySysFile& sysf)
{
 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
//
static void assert_same_ftype(const WySysFile& f1,const WySysFile& f2) 
{
 if(f1.ftype()!=f2.ftype()) {
   WY_THROW( WyRet() );
 }
};

template<typename Dev1, typename Dev2>
static void assert_same_sysf(const Dev1& f1,const Dev2& f2)
{
 assert_same_ftype(f1,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()); }


const WyStr TFifoName("DeleteMe.fifo");

class Chk_Poly {
    const bool _init_ok;

    const WyRegFile RegF_0;
    const WyRegFile RegF_1;
    const WyChrFile ChrF_0;
    const WyChrFile ChrF_1;
    const WyFifoFile Fifo_0;
    const WyFifoFile Fifo_1;
    const WySockFile SktF_0;
    const WySockFile SktF_1;
    const WyTerminal TermF_0;
    const WyTerminal TermF_1;
    bool _init(void) {
           Wy::unlink(TFifoName);
           WyRet r;
           if((r=WyFifoFile::create(TFifoName,S_IRUSR|S_IWUSR))!=Ok) {
             WY_THROW(r);
           }
           return(true);
         };
  public:
    Chk_Poly() 
      try :
        _init_ok(_init()),
        RegF_0(),
        RegF_1(__FILE__,O_RDONLY),
        ChrF_0(),
        ChrF_1("/dev/zero",O_RDONLY),
        Fifo_0(),
        Fifo_1(TFifoName,O_RDWR),
        SktF_0(),
        SktF_1(PF_LOCAL,SOCK_DGRAM),
        TermF_0(),
        TermF_1("/dev/tty",O_RDONLY)
    {
        CHK_DEFAULT(RegF_0);
        CHK_DEFAULT(ChrF_0);
        CHK_DEFAULT(Fifo_0);
        CHK_DEFAULT(SktF_0);
        CHK_DEFAULT(TermF_0);
    }
    catch(const WyRet& e) {
      std::cerr << Wy::wrd(e).c_str() << '\n';
    }
    catch(...) {
      Wy::unlink(TFifoName);
      throw;
    };

    ~Chk_Poly() {
      Wy::unlink(TFifoName);
    };

    void ck_chrfile(void);
    void ck_regfile(void);
    void ck_sockfile(void);
    void ck_fifofile(void);
    void ck_terminal(void);
    void ck_byteflow(void);

} static pchk_obj;

/*
 {
  WyChrFile tmp(RegF_0);
  WyChrFile tmp(RegF_1);
  WyChrFile tmp(ChrF_0);
  WyChrFile tmp(ChrF_1);
  WyChrFile tmp(Fifo_0);
  WyChrFile tmp(Fifo_1);
  WyChrFile tmp(SktF_0);
  WyChrFile tmp(SktF_1);
  WyChrFile tmp(TermF_0);
  WyChrFile tmp(TermF_1);
 }
*/
void Chk_Poly::ck_chrfile(void)
{
 WyRet r;

 {
   {
     try {
      WyChrFile tmp(static_cast<const WySysFile&>(RegF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WyChrFile tmp(static_cast<const WySysFile&>(RegF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
      WyChrFile tmp(ChrF_0);
      CHK_DEFAULT(tmp);
   }
  
   {
      WyChrFile tmp(ChrF_1);
      CHK_SAME_SYSF(tmp,ChrF_1);
   }
  
 }

 {
   {
     try {
      WyChrFile tmp(static_cast<const WyByteFlow&>(Fifo_0));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WyChrFile tmp(static_cast<const WyByteFlow&>(Fifo_1));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WyChrFile tmp(static_cast<const WyByteFlow&>(SktF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WyChrFile tmp(static_cast<const WyByteFlow&>(SktF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyChrFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
      WyChrFile tmp(TermF_0);
      CHK_DEFAULT(tmp);
   }

   {
      WyChrFile tmp(TermF_1);
      CHK_SAME_SYSF(tmp,TermF_1);
   }
 }

 {
   WyChrFile tmp;
   if((r=tmp.reset(static_cast<const WyByteFlow&>(RegF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(RegF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(ChrF_0))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(ChrF_1))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,ChrF_1);

   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   
   if((r=tmp.reset(static_cast<const WyByteFlow&>(SktF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(SktF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(TermF_0))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(TermF_1))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,TermF_1);
 }
};

void Chk_Poly::ck_regfile(void)
{
 WyRet r;

 {
   {
      WyRegFile tmp(RegF_0);
      CHK_DEFAULT(tmp);
   }
  
   {
      WyRegFile tmp(RegF_1);
      CHK_SAME_SYSF(tmp,RegF_1);
   }
 }

 {
   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(ChrF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(ChrF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
 }

 {
   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(Fifo_0));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(Fifo_1));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(SktF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WyRegFile tmp(static_cast<const WySysFile&>(SktF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(TermF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WyRegFile tmp(static_cast<const WyByteFlow&>(TermF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyRegFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

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

   if((r=tmp.reset(static_cast<const WyByteFlow&>(ChrF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(ChrF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   
   if((r=tmp.reset(static_cast<const WyByteFlow&>(SktF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(SktF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(static_cast<const WyByteFlow&>(TermF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(TermF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }
 }
};

void Chk_Poly::ck_sockfile(void)
{
 WyRet r;

 {
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(RegF_0));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(RegF_1));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(ChrF_0));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(ChrF_1));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(Fifo_0));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(Fifo_1));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
      WySockFile tmp(SktF_0);
      CHK_DEFAULT(tmp);
   }

   {
      WySockFile tmp(SktF_1);
      CHK_SAME_SYSF(tmp,SktF_1);
   }
 }

 {
   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(TermF_0));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {
      WySockFile tmp(static_cast<const WyByteFlow&>(TermF_1));
      WY_THROW( WyRet() );
     }
     catch(const WySockFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   WySockFile tmp;
   if((r=tmp.reset(static_cast<const WyByteFlow&>(RegF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(RegF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(static_cast<const WyByteFlow&>(ChrF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(ChrF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }

   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(Fifo_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   
   if((r=tmp.reset(SktF_0))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(SktF_1))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,SktF_1);

   if((r=tmp.reset(static_cast<const WyByteFlow&>(TermF_0)))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.reset(static_cast<const WyByteFlow&>(TermF_1)))!=Wym_EBADF) {
     WY_THROW(r);
   }
 }
};

void Chk_Poly::ck_fifofile(void)
{
 WyRet r;

 {
   {
     try {
      WyFifoFile tmp(static_cast<const WyByteFlow&>(RegF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WyFifoFile tmp(static_cast<const WyByteFlow&>(RegF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
     try {
      WyFifoFile tmp(static_cast<const WyByteFlow&>(ChrF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
  
   {
     try {
      WyFifoFile tmp(static_cast<const WyByteFlow&>(ChrF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   {
      WyFifoFile tmp(Fifo_0);
      CHK_DEFAULT(tmp);
   }

   {
      WyFifoFile tmp(Fifo_1);
      CHK_SAME_SYSF(tmp,Fifo_1);
   }
 }

 {
   {
     try {
      WyFifoFile tmp(static_cast<const WyByteFlow&>(SktF_0));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }

   {
     try {