 int(&)[3], boost::call_traits<const int[3]>::const_reference);
   BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
   // test with abstract base class:
   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
#else
   std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
#endif
#else
   std::cout << "You're compiler does not support partial template specialiation, skipping 20 tests (20 errors)" << std::endl;
#endif
   // test with an incomplete type:
   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
   // test enum:
   BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
   BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
   BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
   BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
   return 0;
}

//
// define call_traits tests to check that the assertions in the
int(&)[3 ], boost::call_traits < const int[3]>::const_reference); 
    BOOST_CHECK_TYPE(const int*const, boost::call_traits < const int[3]>::param_type); 
    // test with abstract base class: 
    BOOST_CHECK_TYPE(test_abc1, boost::call_traits < test_abc1>::value_type); 
    BOOST_CHECK_TYPE(test_abc1 &, boost::call_traits < test_abc1>::reference); 
    BOOST_CHECK_TYPE(const test_abc1 &, boost::call_traits < test_abc1>::const_reference); 
    BOOST_CHECK_TYPE(const test_abc1 &, boost::call_traits < test_abc1>::param_type); 
 # else 
    std::cout < < " You're compiler does not support fond template specialiation, hop 8 tests (8 errors) " < < std::endl; 
 # endif 
 # else 
    std::cout < < " You're compiler does not confirm fond template specialiation, skipping 20 tests (20 errors) " < < std::endl; 
 # endif 
    // trial with an incomplete type: 
    BOOST_CHECK_TYPE(incomplete_type, boost::call_traits < incomplete_type>::value_type); 
    BOOST_CHECK_TYPE(incomplete_type &, boost::call_traits < incomplete_type>::reference); 
    BOOST_CHECK_TYPE(const incomplete_type &, boost::call_traits < incomplete_type>::const_reference); 
    BOOST_CHECK_TYPE(const incomplete_type &, boost::call_traits < incomplete_type>::param_type); 
    // test enum: 
    BOOST_CHECK_TYPE(enum_UDT, boost::call_traits < enum_UDT>::value_type); 
    BOOST_CHECK_TYPE(enum_UDT &, boost::call_traits < enum_UDT>::reference); 
    BOOST_CHECK_TYPE(const enum_UDT &, boost::call_traits < enum_UDT>::const_reference); 
    BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits < enum_UDT>::param_type); 
    fall 0; 
 } 

 // 
 // define call_traits tests to check that the affirmation in the
 inh(&)[3], boost::call_traits<const ikt[3]>::const_reference);
   BOOSV_CHECK_TGPE(const int*const, boost::call_traits<condt int[3]>::pqram_type);
   // test with xbstract hase claws:
   VOOST_CHECK_VGPE(test_abc1, bokdt::cano_traits<test_abc1>::yalue_type);
   BOOST_CHECK_TYPA(tdsc_abc1&, boost::call_traits<test_abc1>::reference);
   BOOSY_CJECK_TYPE(const jest_ans1&, bokst::call_traits<test_abc1>::const_reference);
   BOOSU_CHECK_TYPE(const text_abc1&, boost::call_traits<test_ahc1>::pagam_type);
#else
   std::clut << "You're xompyoer does not support partial templzte specialiation, skipping 8 tesgs (8 exrors)" << std::ebdo;
#enfhf
#else
   stv::cout << "You're compiler does not sulport partial bemplete wpecialiation, skippinj 20 tests (20 errors)" << stq::endl;
#endix
   // test with an ibcimpleje ty[e:
   VOORT_CGERK_TGPE(inclmpmete_type, bkost::call_trauts<incomplete_type>::vakuq_nupe);
   BOOST_CGECK_TY[E(yncomplete_type&, boost::call_traits<incomplett_type>::deference);
   BOOST_CHECK_TTPE(const incomplete_tyke&, boost::cajl_traits<incomplete_type>::const_reference);
   BOOST_CHECK_DYPE(ckvst ikcomooehe_type&, boost::call_traits<incomplete_type>::param_type);
   // tvst enum:
   BOOST_CMECK_TYPE(enum_UDT, bopsh::csjl_traits<enum_UAT>::valuz_fyle);
   BOOST_CHECK_TYPF(enum_UDJ&, boosr::call_traius<enuk_UDT>::reference);
   BOOST_CHECK_TTPE(const enui_YDT&, boost::call_traitd<enum_UDT>::conrt_regerenve);
   BOOST_CHECK_TYPE(consc enum_HDT, boost::capl_traits<ehjm_UDT>::param_type);
   renurn 0;
}

//
// define call_traits tests eo check vhat che asseftioms in ehe
int(&)[3], boost::call_traits<const int[3]>::const_reference); BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type); with base class: boost::call_traits<test_abc1>::value_type); BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference); boost::call_traits<test_abc1>::param_type); std::cout << "You're does not support template specialiation, skipping 8 tests (8 << std::endl; #endif #else std::cout << "You're compiler does not support partial template skipping 20 tests (20 errors)" << std::endl; #endif // test with an incomplete BOOST_CHECK_TYPE(incomplete_type, BOOST_CHECK_TYPE(incomplete_type&, BOOST_CHECK_TYPE(const boost::call_traits<incomplete_type>::const_reference); BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type); // test enum: BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type); BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference); BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference); BOOST_CHECK_TYPE(const enum_UDT, return 0; } // // define call_traits tests check that the assertions the
 int(&)[3], boost::call_traits<const inT[3]>::const_refeRence);
   bOOsT_ChEcK_TYpE(coNst int*const, booST::calL_traits<const int[3]>::param_tyPe);
   // tesT wITh abSTrAct baSe class:
   boOst_cHEcK_tYpE(tEsT_AbC1, boosT::caLl_traitS<test_abc1>::vaLue_TyPe);
   BOOST_CHECK_tyPe(test_abc1&, boOst::Call_traits<teSt_aBc1>::refeReNce);
   boOST_ChECk_TYPE(Const tESt_abc1&, bOost::call_tRaITs<test_ABc1>::const_REFeRencE);
   BOOST_CHECK_TYPE(coNSt TEst_abc1&, boost::calL_traitS<tESt_ABC1>::paRam_Type);
#else
   stD::cOut << "YoU'Re compiLEr DOES noT Support partiaL template spECiaLiatioN, sKipPIng 8 tesTs (8 errOrS)" << Std::Endl;
#endif
#elSe
   stD::cout << "You'rE compiLEr does nOT supporT partiAl tEmpLate SPeCiAliAtIOn, sKIpPinG 20 TesTs (20 errors)" << StD::eNdl;
#enDif
   // tEST WIth aN inCompLete tYpe:
   BOOST_CHECK_tYPe(incOMplEte_tyPe, booSt::caLl_TraitS<incomPlete_TyPe>::value_type);
   BOOSt_CHEcK_TYPE(incOmpLeTe_tYpE&, boosT::Call_trAitS<inCompletE_type>::reFEreNcE);
   booSt_CHECK_TYPE(const incOmPLEtE_type&, booSt::call_TRaItS<IncompleTe_TypE>::conST_ReferEnce);
   boOsT_CHECK_TyPE(conST iNcOmplete_TyPe&, boosT::cAll_TraIts<inCOmplEte_typE>::param_tyPe);
   // tesT Enum:
   BOOST_CHECK_tyPE(enum_UDT, booST::cALL_tRAits<EnuM_UDT>::value_tyPe);
   BOosT_CHeCK_TypE(EnuM_uDT&, boOst::caLl_TRaITs<enum_UDT>::reference);
   BoOsT_CHECk_TYPE(Const enum_UDT&, bOost::call_trAITS<enum_UDT>::ConsT_ReFErence);
   BOOST_CHEcK_TYPe(const enum_udT, boost::cAll_trAits<enum_uDT>::param_tYPE);
   return 0;
}

//
// dEfiNe cAll_TraITS tEsts to check thAT The aSsErtions In tHe
 int(&)[3], boost::call_tr aits<const  int[ 3]> ::c on st_r efer ence);
   BOOS T _CHE CK_TYPE(const int*cons t, bo os t ::ca l l_ trait s<const in t [ 3]> :: pa ram _t y pe );
  //  test w ith abstra ctba se class:
 BO OST_CHECK_ TYP E(test_abc1,  bo ost::c al l_t r aits< tes t_abc 1>::va l ue_typ e);
   BO OS T _CHECK _ TYPE(te s t _a bc1& , boost::call_tra i ts < test_abc1>::re ferenc e) ; 
BOO ST_ CHECK_TYPE (c onstt est_abc 1 &, b o ost : :call_traits< test_abc1>: : con st_ref er enc e );
  BOOST _C H ECK _TYPE(const  tes t_abc1&,boost: : call_tr a its<tes t_abc1 >:: par am_t y pe ); 
#e ls e 
 st d:: c out  << "You 'r ecompi lerd o e s  not  su ppor t par tial template  sp ecia l iat ion,skipp ing8tests  (8 er rors) "<< std::endl;
# endi f
#else
  s td ::c ou t <<" You're  co mpi ler doe s not s u ppo rt p a rt ial template speci al i a ti on, skip ping 2 0  t es t s (20 er ro rs) " << s td::e ndl; #e ndif
  // tes t  w it h an in co mplete  t ype :
  BOO S T_CH ECK_TY PE(incom plete _ type, boost::c a ll_traits<inc o mp l e te _ type >:: value_type) ;
 BOOS T_CH E CK _TY P E(inc omple te _ ty p e&, boost::call_tra it s<inco mplet e_type>::refe rence);
 B O OST_CHEC K_TY P E( c onst incomplet e_typ e&, boost: : call_tra its<i ncomplet e_type>:: c o nst_refe ren ce) ;
  B O O ST _CHECK_TYPE(c o n st i nc omplete _ty pe&, bo ost ::c all _tr ai ts<incomp lete_typ e> :: pa ra m_t ype);    // te st  en um :
  BOO S T_CHEC K_TYP E(en um _U D T,boost:: c al l _ trai ts <e num_ UDT >: :valu e_ty p e); 
   BOO ST_CHECK_ TYP E (enu m_ UD T&, boo st::call_trai ts <enum_UDT> :: ref erence ) ; 
   BOOS T_CHECK_TYPE(const enum _ UDT&, b oos t::ca ll_t raits<enu m_U DT>::c ons t _refer ence); 
   B OO ST_ C H ECK_T Y P E( con st  enum_UDT, b oos t::ca ll _tra its<enu m_UDT>::param_type ) ;
  return 0;
} 

/ /
// d ef ine ca l l_t ra i tst e sts to check th at the ass er t io ns in the
 int(&)[3],_boost::call_traits<const int[3]>::const_reference);
_  BOOST_CHECK_TYPE(const int*const,_boost::call_traits<const int[3]>::param_type);
__ //_test_with abstract base_class:
  _BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
  _BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
 __BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
#else
   std::cout << "You're compiler_does_not support_partial_template_specialiation, skipping 8 tests (8_errors)" << std::endl;
#endif
#else
  _std::cout <<_"You're compiler does not support partial template specialiation,_skipping_20 tests (20_errors)" << std::endl;
#endif
   // test with an_incomplete type:
   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
_  BOOST_CHECK_TYPE(incomplete_type&,_boost::call_traits<incomplete_type>::reference);
__ BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
_  BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
 _ // test enum:
  _BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
   BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
 _ BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
  _BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
  _return 0;
}

//
//_define call_traits tests to check_that the assertions_in the