chk_ret.cpp

一个不错

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

   Note: This test should be after chk_reply

   Build: make chk_ret
*/

#include "wyret.h"
#include "wystr.h"
#include <stdexcept>
#include <iostream>

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

//
// Test the public interface
//
static void t1(void)
{
 if(::strcmp(WyRet()->c_repstr(),Wy::_default_repstr)!=0) {
   WY_THROW(WyRet());
 }
 if(WyRet()->c_repcode()!=-1) {
   WY_THROW(WyRet());
 }

 WyRet r1;              // default constructor
 WyRet r2(Wym_ENOENT);  // construct by errno
 WyRet r3(r2);          // constructor by copy
 WyRet r4(WyReply(0));

 //
 // Basic construct and compare
 //
 if(r1.is_default()==false) {
   WY_THROW(WyRet() );
 }
 if(r2.is_default()) {
   WY_THROW(WyRet() );
 }
 if(r3.is_default()) {
   WY_THROW(WyRet() );
 }
 if(r4.is_default()) {
   WY_THROW(WyRet() );
 }
 if(r1==r2) {
   WY_THROW(WyRet() );
 }
 if(r1!=r2) {
 } else {
   WY_THROW(WyRet() );
 }
 if(r2!=r3) {
   WY_THROW(WyRet() );
 }
 if(r2==r3) {
 } else {
   WY_THROW(WyRet() );
 }

 if(r1==Ok) {
   WY_THROW(WyRet() );
 }
 if(r1!=Ok) {
 } else {
   WY_THROW(WyRet() );
 }
 if(Ok==r1) {
   WY_THROW(WyRet() );
 }
 if(Ok!=r1) {
 } else {
   WY_THROW(WyRet() );
 }

 if(r2==Ok) {
   WY_THROW(WyRet() );
 }
 if(r2!=Ok) {
 } else {
   WY_THROW(WyRet() );
 }
 if(r4==Ok) {
 } else {
   WY_THROW(WyRet() );
 }
 if(r4!=Ok) {
   WY_THROW(WyRet() );
 }
 if(r4.is_default()) {
   WY_THROW(WyRet() );
 }
 if(r2!=Wym_ENOENT) {
   WY_THROW(WyRet() );
 }
 if(r3!=Wym_ENOENT) {
   WY_THROW(WyRet() );
 }
 if(r4!=Ok) {
   WY_THROW(WyRet() );
 }

 // test reset
 r4.reset();
 if(r4.is_default()==false) {
   WY_THROW(WyRet() );
 }
 if(r2.is_default()) {
   WY_THROW(WyRet() );
 }
 r4.reset(r2);
 if(r4!=r2) {
   WY_THROW(WyRet() );
 }
 r4.reset(Wym_EBADF);
 if(r4!=Wym_EBADF) {
   WY_THROW(WyRet() );
 }
 r4=WyReply(0);

 //
 // Test assign
 //
 if(r2.is_default()) {
   WY_THROW(WyRet() );
 }
 r4.reset(r2);
 if(r4!=r2) {
   WY_THROW(WyRet() );
 }
 r4.reset(Wym_EBADF);
 if(r4!=Wym_EBADF) {
   WY_THROW(WyRet() );
 }
 r4=WyReply(-1);
 if(r4.is_default()==false) {
   WY_THROW(WyRet() );
 }
 r4=WyReply(0);

 //
 // Test operator=
 //
 if(r4==r2) {
   WY_THROW(WyRet() );
 }
 WY_HERE(r2);
 r4=r2;
 if(r4!=r2) {
   WY_THROW(WyRet() );
 }
#ifndef WYLIB_CONFIG_NORSLI
 if(r4.sli_ptr()!=r2.sli_ptr()) {
   WY_THROW(WyRet() );
 }
#endif
 r4=Wym_EBADF;
 if(r4!=Wym_EBADF) {
   WY_THROW(WyRet() );
 }
 r4=WyReply(200);
 if(r4.is_default()==false) {
  WY_THROW(WyRet() );
 }
 r4=WyReply(0);

 //
 // Test some c_errno
 //
 if(r1->c_repcode()!=-1) {
   WY_THROW(WyRet() );
 }
 if(r2->c_repcode()!=ENOENT) {
   WY_THROW(WyRet() );
 }
 if(r3->c_repcode()!=ENOENT) {
   WY_THROW(WyRet() );
 }
 if(r4->c_repcode()!=0) {
   WY_THROW(WyRet() );
 }

 //
 // Test description
 //
 r2=r3;
 if(Wy::wrd(r2)!=Wy::wrd(r3)) {
   WY_THROW(WyRet() );
 }

 // Is really derived from WyReply?
 {
  WyRet r(Wym_EINVAL);
  WyReply em(r);
  if(em!=Wym_EINVAL) {
    WY_THROW(WyRet() );
  }
 }
};

//
// Test the public interface involving source location.
//
static void t2(void)
{
 static const Wy_SrcLoc loc1(__FILE__,__LINE__);
 static const Wy_SrcLoc loc2(__FILE__,__LINE__);

 if(loc1.src_line()+1!=loc2.src_line()) {
   WY_THROW(WyRet() );
 }
 if(std::string(loc1.src_file())!=std::string(__FILE__)) {
   WY_THROW(WyRet() );
 }
 WyRet r1(Wym_EINVAL); 
 WyRet r2(Wym_EPERM);

#ifndef WYLIB_CONFIG_NORSLI
 r1.set_sli(&loc1);
 r2.set_sli(&loc2);
#endif

 if(r1!=Wym_EINVAL) {
   WY_THROW(WyRet() );
 }
#ifndef WYLIB_CONFIG_NORSLI
 if(r1.sli_ptr()!=&loc1) {
   WY_THROW(WyRet() );
 }
#endif

 WyRet r3;
 if(r3.is_default()==false) {
   WY_THROW(WyRet() );
 }
 if(r3==Ok) {
   WY_THROW(WyRet() );
 }
 r3.reset(r2);
 if(r3.is_default()==true) {
   WY_THROW(WyRet() );
 }
 if(r3!=r2) {
   WY_THROW(WyRet() );
 }
#ifndef WYLIB_CONFIG_NORSLI
 r3.set_sli(&loc2);
#endif
 if(r3!=r2) {
   WY_THROW(WyRet() );
 }
 if(r2==r3) {
 } else {
   WY_THROW(WyRet() );
 }

 // chk move ctor
 {
  char raw_buf[2*sizeof(WyRet)];
  ::memset(raw_buf,0,sizeof(raw_buf));
  WyRet* const p1( reinterpret_cast<WyRet*>(raw_buf) );
  WyRet* const p2(p1+1);
  WyRet Smp( Wym_EIO );
#ifndef WYLIB_CONFIG_NORSLI
  WY_HERE(Smp);
#endif

  new(p1) WyRet(Smp);
  if(*p1!=Smp) {
    WY_THROW( WyRet() );
  }

  // move *p1 to p2
  try {
    new(p2) WyRet(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~WyRet();
    throw;
  };
  if(*p2!=Smp) {
    WY_THROW( WyRet() );
  }
  if((*p2)->c_repstr()!=Smp->c_repstr()) {
    WY_THROW( WyRet() );
  }
  if((*p2)->c_repcode()!=Smp->c_repcode()) {
    WY_THROW( WyRet() );
  }
  if((*p2)->get_reply(NULL,0)!=Smp->get_reply(NULL,1)) {
    WY_THROW( WyRet() );
  }
#ifndef WYLIB_CONFIG_NORSLI
  if(p2->sli_ptr()!=Smp.sli_ptr()) {
    WY_THROW( WyRet() );
  }
#endif
  p2->~WyRet();
 }
};

//
// Check Reply
//
static void t_fault(void)
{
 WY_THROW_REPLY;

 if(sizeof(Reply)!=sizeof(WyRet)) {
   WY_THROW(WyRet());    // Reply should not add any data member
 }

 try {
   WY_THROW( Reply(Wym_ENOMEM) );
   WY_THROW( WyRet() );
 }
 catch(const Reply& e) {
   if(e!=Wym_ENOMEM) {
     WY_THROW( WyRet(e) );
   }
 };

 try {
   WY_THROW( Reply(Wym_ENOMEM) );
   WY_THROW( WyRet() );
 }
 catch(WyRet e) {
   if(e!=Wym_ENOMEM) {
     WY_THROW(e);
   }
 };

 try {
   WY_THROW( Reply(Wym_ENOMEM) );
   WY_THROW( WyRet() );
 }
 catch(const WyRet& e) {
   if(e!=Wym_ENOMEM) {
     WY_THROW( WyRet(e) );
   }
 };

 try {
   WY_THROW( WyRet(Wym_ENOMEM) );
   WY_THROW( WyRet() );
 }
 catch(const Reply&) {
   throw;
 }
 catch(const WyRet& e) {
   if(e!=Wym_ENOMEM) {
     WY_THROW( WyRet(e) );
   }
 };
};

static const std::string chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking WyRet ...\n";
 std::cout << "sizeof(WyRet)=" << sizeof(WyRet) << std::endl;
 std::cout << "sizeof(std::logic_error)=" << sizeof(std::logic_error) << std::endl;
 if(sizeof(WyRet)>sizeof(std::logic_error)) {
   std::cerr << "Warning: " <<
    "sizeof(WyRet)>sizeof(std::logic_error)"
   << std::endl;
   WY_THROW(WyRet() );
 }
#ifndef WYLIB_CONFIG_NORSLI
 if(sizeof(WyRet)!=sizeof(WyReply)+sizeof(Wy_SrcLoc*)) {
   WY_THROW(WyRet() );
 }
#else
 if(sizeof(WyRet)!=sizeof(WyReply)) {
   WY_THROW(WyRet() );
 }
#endif
 t1(); 
 t2();
 t_fault();
 std::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 std::cerr << chdr << Wy::wrd(e).c_str() << std::endl;
 return(-1);
}
catch(const std::exception& e) {
 std::cerr << chdr << "std::exception" << std::endl;
 return(-1);
}
catch(...) {
 std::cerr << chdr << "unknown unwind" << std::endl;
 return(-1);
};