chk_seg.cpp

一个不错

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

   Build: make chk_seg
*/

#include "wyret.h"
#include "wyseg.h"
#include <iostream>

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

template<typename T>
void verify_equ(const T& s1,const T& s2)
{
 if(s1.size()!=s2.size()) {
   WY_THROW( WyRet() );
 }
 if(s1.begin()!=s2.begin()) {
   WY_THROW( WyRet() );
 }
 if(s1.is_overlap(s2)==false) {
   WY_THROW( WyRet() );
 }
 if(s2.is_overlap(s1)==false) {
   WY_THROW( WyRet() );
 }
 if(s1.end()!=s2.end()) {
   WY_THROW( WyRet() );
 }
 if(&s1[0]!=&s2[0]) {
   WY_THROW( WyRet() );
 }
 if(s1!=s2) {
   WY_THROW( WyRet() );
 }
};

#define CHK_EQU(s1,s2) try { verify_equ(s1,s2); } catch(...) { WY_THROW( WyRet()); };

static void ck_seg_char(void)
{
 WyRet r;

 // chk ctor WySeg<char>
 {
  char str1[]={'1','2','3'};
  char str3[]={'x','y','z',0x5c};
  WySeg<char> s1(str1,3),s2(s1),s3(str3,4);
  CHK_EQU(s1,s2);
  if(s1.size()!=3) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=&str1[0]) {
    WY_THROW( WyRet() );
  }
  if(s1.end()!=&str1[sizeof(str1)]) {
    WY_THROW( WyRet() );
  }
  if((s1[0]!='1')||(s1[1]!='2')||(s1[2]!='3')) {
    WY_THROW( WyRet() );
  }
  if(s3.size()!=4) {
    WY_THROW( WyRet() );
  }
  if(s3.begin()!=&str3[0]) {
    WY_THROW( WyRet() );
  }
  if(s3.end()!=s3.begin()+s3.size()) {
    WY_THROW( WyRet() );
  }
  if((s3[0]!='x')||(s3[1]!='y')||(s3[2]!='z')||(s3[3]!=0x5c)) {
    WY_THROW( WyRet() );
  }
  
  // throw
  try {
    WySeg<char> ss(NULL,3);
    WY_THROW( WyRet() );
  }
  catch(const WySeg<char>::Reply& e) {
    if(e!=Wym_EFAULT) {
      WY_THROW( WyRet(e) );
    }
  };

  try {
    WySeg<char> ss((char*)NULL,(char*)NULL);
    WY_THROW( WyRet() );
  }
  catch(const WySeg<char>::Reply& e) {
    if(e!=Wym_EFAULT) {
      WY_THROW( WyRet(e) );
    }
  };

 }

 // chk ctor WySeg<const char>
 {
  char str1[]={'a','2','3'};
  char str3[]={'a','y','z',0x7a};
  WySeg<const char> s1(str1,3),s2(s1),s3(str3,4);
  CHK_EQU(s1,s2);
  if(s1.size()!=3) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=&str1[0]) {
    WY_THROW( WyRet() );
  }
  if((s1[0]!='a')||(s1[1]!='2')||(s1[2]!='3')) {
    WY_THROW( WyRet() );
  }
  if(s3.size()!=4) {
    WY_THROW( WyRet() );
  }
  if(s3.begin()!=&str3[0]) {
    WY_THROW( WyRet() );
  }
  if((s3[0]!='a')||(s3[1]!='y')||(s3[2]!='z')||(s3[3]!=0x7a)) {
    WY_THROW( WyRet() );
  }
 }

 // chk ctor WySeg<const char>
 {
  const char str1[]="123";
  const char str3[]="xyz";
  WySeg<const char> s1(str1,3),s2(s1),s3(str3,4);
  CHK_EQU(s1,s2);
  if(s1.size()!=3) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=&str1[0]) {
    WY_THROW( WyRet() );
  }
  if((s1[0]!='1')||(s1[1]!='2')||(s1[2]!='3')) {
    WY_THROW( WyRet() );
  }
  if(s3.size()!=4) {
    WY_THROW( WyRet() );
  }
  if(s3.begin()!=&str3[0]) {
    WY_THROW( WyRet() );
  }
  if((s3[0]!='x')||(s3[1]!='y')||(s3[2]!='z')||(s3[3]!=0)) {
    WY_THROW( WyRet() );
  }
 }

 // ctr
 {
  const char* tmp="helo";
  WySeg<const char> s1(tmp,tmp+4);
  if(s1.size()!=4) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=&tmp[0]) {
    WY_THROW( WyRet() );
  }
  if((s1[0]!='h')||(s1[1]!='e')||(s1[2]!='l')||(s1[3]!='o')) {
    WY_THROW( WyRet() );
  }

  WySeg<const char> s2(tmp+1,tmp+1);
  if(s2.begin()!=&tmp[1]) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=0) {
    WY_THROW( WyRet() );
  }
 }

 // reset(const WySeg&), operator=
 {
  const char str[]="kajsdfk";
  WySeg<const char> s1(str,sizeof(str)),s2("a",1);
  if(s1.size()!=sizeof(str)) {
    WY_THROW( WyRet() );
  }
  s2.reset(s1);
  CHK_EQU(s1,s2);

  s1.reset(str,sizeof(str));
  s2.reset(str,str+sizeof(str));
  CHK_EQU(s1,s2);

  if((r=s2.reset(NULL,size_t(0)))!=Wym_EFAULT) {
    WY_THROW(r);
  }
  if((r=s2.reset(str+1,2))!=Ok) {
    WY_THROW(r);
  }
  if(s2.size()!=2) {
    WY_THROW( WyRet() );
  }
  if((s2[0]!='a')||(s2[1]!='j')) {
    WY_THROW( WyRet() );
  }

  if((r=s2.reset(str+2,str+1))!=Wym_ERANGE) {
    WY_THROW(r);
  }
  if((r=s2.reset(str,(const char*)NULL))!=Wym_EFAULT) {
    WY_THROW(r);
  }
  if((r=s2.reset(str+2,3))!=Ok) {  // "jsd"
    WY_THROW(r);
  }
  if(s2.size()!=3) {
    WY_THROW( WyRet() );
  }
  if((s2[0]!='j')||(s2[1]!='s')) {
    WY_THROW( WyRet() );
  }

  s1=s2;
  if(s1!=s2) {
    WY_THROW( WyRet() );
  }

  if((r=s1.reset(NULL,1))!=Wym_EFAULT) {
    WY_THROW( WyRet() );
  }
  if((r=s1.reset((const char*)NULL,(const char*)NULL))!=Wym_EFAULT) {
    WY_THROW( WyRet() );
  }
  if((r=s1.reset(str+2,str+1))!=Wym_ERANGE) {
    WY_THROW( WyRet() );
  }
 }

 // swap(..)
 {
  const char cstr1[]="ab";
  const char cstr2[]="fgg";
  WySeg<const char> s1(cstr1,sizeof(cstr1));
  WySeg<const char> s2(cstr2,sizeof(cstr2));
  if(s1.begin()!=cstr1) {
    WY_THROW( WyRet() );
  }
  if(s1.size()!=sizeof(cstr1)) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=cstr2) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=sizeof(cstr2)) {
    WY_THROW( WyRet() );
  }

  s1.swap(s2);
  if(s1.begin()!=cstr2) {
    WY_THROW( WyRet() );
  }
  if(s1.size()!=sizeof(cstr2)) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=cstr1) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=sizeof(cstr1)) {
    WY_THROW( WyRet() );
  }
 }

 // chk operator [](size_t)
 {
  const char cstr[]="1234567";
  WySeg<const char> s1(cstr,sizeof(cstr));
  if(s1.size()!=sizeof(cstr)) {
    WY_THROW( WyRet() );
  }
  if((s1[0]!='1')||(s1[1]!='2')) {
    WY_THROW( WyRet() );
  }
  try {
    if(s1[s1.size()]==0) {
      WY_THROW( WyRet() );
    }
    WY_THROW( WyRet() );
  }
  catch(const WySeg<const char>::Reply& e) {
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet() );
    }
  };

  char cstr2[]={'a','4','y'};
  WySeg<char> s2(cstr2,sizeof(cstr2));
  if(s2.size()!=sizeof(cstr2)) {
    WY_THROW( WyRet() );
  }
  if((s2[0]!='a')||(s2[1]!='4')) {
    WY_THROW( WyRet() );
  }
  ++s2[0];

  try {
    if(s2[s1.size()+1]==0) {
      WY_THROW( WyRet() );
    }
    WY_THROW( WyRet() );
  }
  catch(const WySeg<char>::Reply& e) {
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet() );
    }
  };
 }

 // chk subseg(size_t,size_t)
 {
  const char cstr[]="1234567";
  WySeg<const char> s(cstr,sizeof(cstr));
  if(::memcmp(s.subseg(0,3).begin(),"123",3)!=0) {
    WY_THROW( WyRet() );
  }
  if(::memcmp(s.subseg(2,2).begin(),"34",2)!=0) {
    WY_THROW( WyRet() );
  }
  if(s.subseg(3).size()!=5) {
    WY_THROW( WyRet() );
  }
  if(::memcmp(s.subseg(3).begin(),"4567",5)!=0) {
    WY_THROW( WyRet() );
  }

  try {
    s.subseg(100);
    WY_THROW( WyRet() );
  }
  catch(const WySeg<const char>::Reply& e) {
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet(e) );
    }
  };

  try {
    s.subseg(100,100);
    WY_THROW( WyRet() );
  }
  catch(const WySeg<const char>::Reply& e) {
    if(e!=Wym_EINVAL) {
      WY_THROW( WyRet(e) );
    }
  };
 }

 // is_overlap(const SegType&)
 {
  const char cstr1[]="x", cstr2[]="aa";
  WySeg<const char> s1(cstr1,sizeof(cstr1)),s2(cstr2,sizeof(cstr2));
  if(s1.is_overlap(s2)) {
    WY_THROW( WyRet() );
  }
  if(s2.is_overlap(s2.subseg(1))==false) {
    WY_THROW( WyRet() );
  }
 }
 
 // chk move ctor
 {
  char buf[2*sizeof(WySeg<char>)];
  ::memset(buf,0,sizeof(buf));
  WySeg<char> *p=reinterpret_cast<WySeg<char>*>(buf);
  char str[]="bnmx";
  new(p) WySeg<char>(str,sizeof(str));
  new(p+1) WySeg<char>(*p,Wy::ByMove);
  if(((p+1)->begin()!=str)||(p+1)->size()!=sizeof(str)) {
    WY_THROW( WyRet() );
  }
 }
};

template<typename T>
static void ck_seg(void)
{
 WyRet r;
 
 // WySeg(T*,size), WySeg(const WySeg&), WySeg(T*,T*)
 {
  T arr1[5]={};
  WySeg<T> s1(arr1,sizeof(arr1)/sizeof(T)),s2(s1),s3(&arr1[1],&arr1[2]);
  CHK_EQU(s1,s2);
  if(s3==s1) {
    WY_THROW( WyRet() );
  }
  if(s3==s2) {
    WY_THROW( WyRet() );
  }
  if(s3!=s1) {
  } else {
    WY_THROW( WyRet() );
  }
  if(s3!=s2) {
  } else {
    WY_THROW( WyRet() );
  }
  if(s1.size()!=5) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=&arr1[0]) {
    WY_THROW( WyRet() );
  }
  if(s1.end()!=&arr1[sizeof(arr1)/sizeof(T)]) {
    WY_THROW( WyRet() );
  }
  if(s3.size()!=1) {
    WY_THROW( WyRet() );
  }
  if(s3.begin()!=&arr1[1]) {
    WY_THROW( WyRet() );
  }
  if(s3.end()!=&arr1[2]) {
    WY_THROW( WyRet() );
  }
 }

 // reset(const WySeg<T>&), reset(T*,size_t), reset(T*, T*), operator=
 {
  T arr[5]={};
  WySeg<T> s1(arr,1),s2(arr+1,2);
  if(s1.size()!=1) {
    WY_THROW( WyRet() );
  }
  if(s1.begin()!=arr) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=2) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=arr+1) {
    WY_THROW( WyRet() );
  }

  s1.reset(s2);
  CHK_EQU(s1,s2);

  s2.reset(arr+2,2);
  if(s2.size()!=2) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=arr+2) {
    WY_THROW( WyRet() );
  }

  s2.reset(arr+1,arr+2);
  if(s2.size()!=1) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=arr+1) {
    WY_THROW( WyRet() );
  }

  s1=s2;
  if(s1!=s2) {
    WY_THROW( WyRet() );
  }

  s1.reset(arr,size_t(0));
  s2.reset(arr+1,size_t(0));
  if(s1==s2) {
    WY_THROW( WyRet() );
  } else {
  }
  if(s1!=s2) {
  } else {
    WY_THROW( WyRet() );
  }
 }

 // swap(..)
 {
  T str1[5]={}, str2[5]={};
  WySeg<T> s1(str1,sizeof(str1));
  WySeg<T> s2(str2,sizeof(str2));
  if(s1.begin()!=str1) {
    WY_THROW( WyRet() );
  }
  if(s1.size()!=sizeof(str1)) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=str2) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=sizeof(str2)) {
    WY_THROW( WyRet() );
  }

  s1.swap(s2);

  if(s1.begin()!=str2) {
    WY_THROW( WyRet() );
  }
  if(s1.size()!=sizeof(str2)) {
    WY_THROW( WyRet() );
  }
  if(s2.begin()!=str1) {
    WY_THROW( WyRet() );
  }
  if(s2.size()!=sizeof(str1)) {
    WY_THROW( WyRet() );
  }
 }

 // chk operator [](size_t)
 {
  T str[5]={};
  WySeg<T> s(str,sizeof(str));
  if((&s[0]!=str+0)||(&s[1]!=str+1)) {
    WY_THROW( WyRet() );
  }
 }

 // chk subseg(size_t,size_t)
 {
  T str[8]={};
  WySeg<T> s1(str,sizeof(str)),s2=s1;

  s2=s1.subseg(1);
  if(s2.size()!=s1.size()-1);
  if(s2.begin()!=s1.begin()+1) {
    WY_THROW( WyRet() );
  }
  s2=s1.subseg(2,2);
  if(s2.size()!=2);
  if(s2.begin()!=s1.begin()+2) {
    WY_THROW( WyRet() );
  }
 }

 // is_overlap(const WySeg<T>&)
 {
  T str1[6]={},str2[7]={};
  WySeg<T> s1(str1,sizeof(str1)/sizeof(T)),s2(str2,sizeof(str2)/sizeof(T));
  if(s1.is_overlap(s2)) {
    WY_THROW( WyRet() );
  }
  s2=s1;
  if(s1.is_overlap(s2)==false) {
    WY_THROW( WyRet() );
  }
 }

 // chk move ctor
 {
  T str1[7]={};
  char buf[2*sizeof(WySeg<T>)];
  ::memset(buf,0,sizeof(buf));
  WySeg<T> *p=reinterpret_cast<WySeg<T>*>(buf);
  new(p) WySeg<T>(str1,7);
  new(p+1) WySeg<T>(*p,Wy::ByMove);
  if((p+1)->begin()!=str1) {
    WY_THROW( WyRet() );
  }
  if((p+1)->size()!=7) {
    WY_THROW( WyRet() );
  }
 }
};

static const char* chdr(
                  "+---------------+\n"
                  "| main() caught:|\n"
                  "+---------------+\n");
int main(void) throw()
try {
 std::cout << "Checking wyseg.h ...\n";
 ck_seg_char();
 ck_seg<char>();
 ck_seg<signed char>();
 ck_seg<unsigned char>();
 ck_seg<const char>();
 ck_seg<const signed char>();
 ck_seg<const unsigned char>();
 ck_seg<signed int>();
 ck_seg<unsigned int>();
 ck_seg<const signed int>();
 ck_seg<const unsigned int>();
 ck_seg<float>();
 ck_seg<float>();
 std::cout << "Checked Ok\n";
 return(0);
}
catch(const WyRet& e) {
 std::cerr << chdr << "WyRet is thrown. c_repcode()="
           << e->c_repcode() <<  ", c_repstr()=" << e->c_repstr();
 #ifndef WYLIB_CONFIG_NORSLI
 if(e.sli_ptr()==NULL) {
 } else {
   std::cerr << ", File= "<< e.sli_ptr()->src_file() 
             << ", Line=" << e.sli_ptr()->src_line();
 }
 #endif
 std::cerr << 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);
};