chk_poly.cpp

一个不错

      WyFifoFile tmp(static_cast<const WyByteFlow&>(SktF_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&>(TermF_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&>(TermF_1));
      WY_THROW( WyRet() );
     }
     catch(const WyFifoFile::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

 {
   WyFifoFile 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(Fifo_0))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(Fifo_1))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,Fifo_1);
   
   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_terminal(void)
{
 WyRet r;

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

 {
   {
      WyTerminal tmp(ChrF_0);
      CHK_DEFAULT(tmp);
   }
  
   {
     try {
      WyTerminal tmp(ChrF_1);
      WY_THROW( WyRet() );
     }
     catch(const WyTerminal::Reply& e) {
       if(e!=Wym_EBADF) {
         WY_THROW( WyRet(e) );
       }
       // FALLTHROUGH
     };
   }
 }

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

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

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

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

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

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

 {
   WyTerminal 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))!=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(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);
 }
};

// some WyByteFlow members are checked here
//
void Chk_Poly::ck_byteflow(void)
{
 WyRet r;

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

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

 {
   {
      WyByteFlow tmp(Fifo_0);
      CHK_DEFAULT(tmp);
   }
  
   {
      WyByteFlow tmp(Fifo_1);
      CHK_SAME_SYSF(tmp,Fifo_1);
   }
 }

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

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

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

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

 {
   WyByteFlow 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(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(Fifo_0))!=Ok) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if((r=tmp.reset(Fifo_1))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,Fifo_1);
   
   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(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);
 }
};

static void ck_poly_1(void)
{
 const char FifoPath[]="tmp.chk_poly.fifo.tmp";
 const bool IsRoot(::getuid()==0);
 WyRet r;

 Wy::unlink(FifoPath);
 if((r=WyFifoFile::create(FifoPath,S_IRUSR|S_IWUSR))!=Ok) {
   WY_THROW(r);
 }

 try {
  const WyRegFile C_RegFile_0;
  const WyChrFile C_ChrFile_0;
  const WyTerminal C_Terminal_0;
  const WyFifoFile C_FifoFile_0;
  const WySockFile C_SockFile_0;

  const WyRegFile C_RegFile(TestFile_1A,O_RDONLY);
  
  WyChrFile C_ChrFile;
  if(IsRoot) {
    if((r=C_ChrFile.reset("/dev/mouse",O_RDONLY))!=Ok) {
      WY_THROW(r);
    }
  } else {
    if((r=C_ChrFile.reset("/dev/tty",O_RDONLY))!=Ok) {
      WY_THROW(r);
    }
  }
  const WyTerminal C_Terminal("/dev/tty",O_RDONLY);
  const WyFifoFile C_FifoFile(FifoPath,O_RDWR);
  const WySockFile C_SockFile(PF_LOCAL,SOCK_STREAM,0);

  // chk WyChrFile(const WyByteFlow&)
  {
   WyChrFile tmp(Wy::cerr);  // cerr assumed a chrfile
   CHK_SAME_SYSF(tmp,Wy::cerr);

   WyChrFile tmp2(static_cast<const WyByteFlow&>(C_Terminal));
   CHK_SAME_SYSF(tmp2,C_Terminal);
  }

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

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

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

  // chk WyRegFile(const WyByteFlow&)
  {
   WyRegFile tmp(C_RegFile);
   CHK_SAME_SYSF(tmp,C_RegFile);

   WyRegFile tmp2(static_cast<const WyByteFlow&>(C_RegFile));
   CHK_SAME_SYSF(tmp2,C_RegFile);
  }

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

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

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

  // chk WySockFile(const WyByteFlow&)
  {
   WySockFile tmp(C_SockFile);
   CHK_SAME_SYSF(tmp,C_SockFile);

   WySockFile tmp2(static_cast<const WyByteFlow&>(C_SockFile_0));
   CHK_SAME_SYSF(tmp2,C_SockFile_0);
  }

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

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

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

  // chk WyFifoFile(const WyByteFlow&)
  {
   WyFifoFile tmp(C_FifoFile);
   CHK_SAME_SYSF(tmp,C_FifoFile);

   WyFifoFile tmp2(static_cast<const WyByteFlow&>(C_FifoFile));
   CHK_SAME_SYSF(tmp2,C_FifoFile);
  }

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

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

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

  // chk WyTerminal(const WyByteFlow&)
  {
   WyTerminal tmp(C_Terminal);
   CHK_SAME_SYSF(tmp,C_Terminal);

   WyTerminal tmp2(static_cast<const WyByteFlow&>(C_Terminal));
   CHK_SAME_SYSF(tmp2,C_Terminal);
  }

  try {
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_RegFile));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };
  try {
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_RegFile_0));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };

  if(IsRoot) {
    try {
      WyTerminal tmp(C_ChrFile);
      WY_THROW( WyRet() );
    } catch(const WyTerminal::Reply& e) {
      if(e!=Wym_EBADF) {
        throw(e);
      }
    };
    try {
      WyTerminal tmp(static_cast<const WyByteFlow&>(C_ChrFile_0));
      WY_THROW( WyRet() );
    } catch(const WyTerminal::Reply& e) {
      if(e!=Wym_EBADF) {
        throw(e);
      }
    };
  }

  try {
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_FifoFile));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };
  try {
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_FifoFile_0));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };

  try {
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_SockFile));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };
  try { 
    WyTerminal tmp(static_cast<const WyByteFlow&>(C_SockFile_0));
    WY_THROW( WyRet() );
  } catch(const WyTerminal::Reply& e) {
    if(e!=Wym_EBADF) {
      throw(e);
    }
  };

 }
 catch(...) {
   Wy::unlink(FifoPath);
   throw;
 };
 Wy::unlink(FifoPath);
};

static void ck_poly_2(void)
{
  pchk_obj.ck_chrfile();
  pchk_obj.ck_regfile();
  pchk_obj.ck_sockfile();
  pchk_obj.ck_fifofile();
  pchk_obj.ck_terminal();
  pchk_obj.ck_byteflow();
};

static const WyStr chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking polymorphism of system file classes ...\n";
 ck_poly_1();
 ck_poly_2();
 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);
};