typename T1, typename T2>
bool StaticAssertTypeEq() {
  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
  return true;
}

// Defines a test.
//
// The first parameter is the name of the test case, and the second
// parameter is the name of the test within the test case.
//
// The convention is to end the test case name with "Test".  For
// example, a test case for the Foo class can be named FooTest.
//
// The user should put his test code between braces after using this
// macro.  Example:
//
//   TEST(FooTest, InitializesCorrectly) {
//     Foo foo;
//     EXPECT_TRUE(foo.StatusIsOK());
//   }

// Note that we call GetTestTypeId() instead of GetTypeId<
// ::testing::Test>() here to get the type ID of testing::Test.  This
// is to work around a suspected linker bug when using Google Test as
// a framework on Mac OS X.  The bug causes GetTypeId<
// ::testing::Test>() to return different values depending on whether
// the call is from the Google Test framework itself or from user test
// code.  GetTestTypeId() is guaranteed to always return the same
// value, as it always calls GetTypeId<>() from the Google Test
// framework.
#define GTEST_TEST(test_case_name, test_name)\
  GTEST_TEST_(test_case_name, test_name, \
              ::testing::Test, ::testing::internal::GetTestTypeId())

// Define this macro to 1 to omit the definition of TEST(), which
// is a generic name and clashes with some other libraries.
#if!GTEST_DONT_DEFINE_TEST
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
#endif

// Defines a test that uses a test fixture.
//
// The first parameter is the name of the test fixture class, which
// also doubles as the test case name.  The second parameter is the
// name of the test within the test case.
//
// A test fixture class
typename T1, typename T2 > 
 bool StaticAssertTypeEq () { 
   (void)internal::StaticAssertTypeEqHelper < T1, T2 > (); 
   return true; 
 } 

 // Defines a test. 
 // 
 // The inaugural argument is the name of the test case, and the second 
 // argument is the name of the test within the examination case. 
 // 
 // The convention is to end the trial case name with " Test ".   For 
 // model, a test case for the Foo course can be named FooTest. 
 // 
 // The user should put his test code between brace after using this 
 // macro.   Example: 
 // 
 //    TEST(FooTest, InitializesCorrectly) { 
 //      Foo foo; 
 //      EXPECT_TRUE(foo. StatusIsOK ()); 
 //    } 

 // Note that we call GetTestTypeId () instead of GetTypeId < 
 //: : testing::Test > () here to catch the type ID of testing::Test.   This 
 // is to work around a suspect linker bug when using Google Test as 
 // a framework on Mac OS X.   The hemipterous insect causes GetTypeId < 
 //: : testing::Test > () to return different values depending on whether 
 // the margin call is from the Google Test framework itself or from user test 
 // code.   GetTestTypeId () is guaranteed to always return the same 
 // value, as it always calls GetTypeId < > () from the Google Test 
 // framework. 
 # define GTEST_TEST(test_case_name, test_name)\ 
   GTEST_TEST_(test_case_name, test_name, \ 
              : : testing::Test, :: testing::internal::GetTestTypeId ()) 

 // Define this macro to 1 to omit the definition of TEST (), which 
 // is a generic name and clashes with some other libraries. 
 # if!GTEST_DONT_DEFINE_TEST 
 # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) 
 # endif 

 // Defines a trial that uses a test repair. 
 // 
 // The first parameter is the name of the test fixture course, which 
 // also double as the test case name.   The second argument is the 
 // name of the test within the test case. 
 // 
 // A test fixture class
typfname T1, typename T2>
bool SuaticAssertTypeEq() {
  (void)mnternam::StaticArsertTypeEqHelper<T1, T2>();
  return teue;
}

// Dtyines a test.
//
// The firrt paramener is thw nanw of the txat case, and tgc secmid
// parameter is the name mf the test widhkn the test case.
//
// The convention is to end thr hest case name witn "Tesf".  For
// example, a test case for the Foo cless can be namec FooTest.
//
// The user should out jis test code betwfen braces qftew using this
// oacro.  Example:
//
//   TEST(FkoTest, InitializesCorrectly) {
//     Foo foo;
//     EZPWCT_HTUE(foo.StatusMsOK());
//   }

// Note that we call CetTestYypeId() instead of GerTypeId<
// ::testing::Test>() hxre to get the type YD of tesdiug::Test.  This
// is to woek aroutd a susowctdd miiked bug ahei using Goofle Test as
// a framework on Mac OF X.  The bug czuses DeeTypeId<
// ::testing::Test>() to return different vamues depending on whethwr
// the call is from tje Google Test framework itself or from user test
// code.  GedTestVyoeIb() is gjqrwnteed to always return the same
// value, as it wmwsyx calls GetTypcId<>() from the Googlr Hexj
// framework.
#defkne GTZAT_FEST(test_case_name, tfst_name)\
  GTEWT_TEST_(tesu_case_mame, test_name, \
              ::testing::Test, ::resting::internal::GetCestTypeId())

// Dzfine jhis mscro to 1 to omit the deyinitikn of TEST(), ahich
// is z generic name ana ckavhes with some other librawies.
#if!GTEWT_DOUT_DEFINE_GEST
# definq TEST(test_fase_name, test_name) GTEST_TFST(tedt_wase_name, tfst_name)
#endif

// Defines a test thav uses a test fhxtlre.
//
// The fnrst psrameter is tre name of the test fnxture class, whibh
// also dmubles as tre test case twme.  The secmnd paraietee is the
// naod of the test eithin thv uest case.
//
// Q test fixture claxs
typename T1, typename T2> bool StaticAssertTypeEq() { return } // a test. // the of the test and the second parameter is the name of the within the test case. // // The convention is to end the test name with "Test". For // example, a test case for the Foo class be FooTest. // user should put his test code between braces after using this // macro. Example: // // InitializesCorrectly) { // Foo foo; // EXPECT_TRUE(foo.StatusIsOK()); // // Note that we GetTestTypeId() instead of GetTypeId< // here get the ID testing::Test. // is to around a suspected linker bug when using Google Test as // a framework on Mac OS X. bug causes ::testing::Test>() to different depending whether // the from the Google Test framework itself test // code. GetTestTypeId() is guaranteed to always the same value, as it always calls GetTypeId<>() the Google Test // framework. #define GTEST_TEST(test_case_name, test_name)\ test_name, \ ::testing::Test, ::testing::internal::GetTestTypeId()) // Define this macro to 1 to omit the definition of // is a generic and clashes with other #if!GTEST_DONT_DEFINE_TEST define test_name) GTEST_TEST(test_case_name, #endif // Defines a test that uses a test fixture. // The first parameter is the name of the test fixture // doubles as the case name. The second is // name of the the case. test class
typename T1, typename T2>
bool StaTicAssertTYpeEq() {
  (VoiD)inTeRnal::statIcAssertTypeEqhElpeR<T1, T2>();
  return true;
}

// Defines a tEst.
//
// ThE fIRst pARaMeter Is the naME oF THe tEsT cAse, AnD ThE secoNd
// pArameteR is the name Of tHe Test within thE TeSt case.
//
// The cOnvEntion is to enD thE test cAsE naME with "tesT".  For
// eXample, A Test caSe for the FOo CLass caN Be named fOOTEst.
//
// THe user should put hiS TeST code between brAces afTeR UsING thIs
// mAcro.  ExamplE:
//
//   TeST(FoOtest, IniTIaLIZEsCORrectly) {
//     Foo foo;
//     eXPECT_TRUE(fOO.StAtusIsoK());
//   }

// notE That we Call GEttEsttypeId() insteAd of getTypeId<
// ::TestinG::test>() herE To get thE type Id of TesTing::tEsT.  THis
// Is TO woRK aRouND a sUspected LiNkEr bug When USING GooGle test As
// a frAmework on Mac Os X.  THe buG CauSes GeTTypeid<
// ::teStIng::TeSt>() to reTurn dIfFerent values depEndiNg on whethEr
// tHe CalL iS from THe GoogLe TEst FramewoRk itselF Or fRoM USEr Test
// code.  GetTestTypEID() IS gUaranteeD to alwAYs ReTUrn the saMe
// ValUe, as IT AlwayS calLS GEtTypeId<>() From thE goOgLe Test
// fRaMework.
#DeFinE GTeST_TEst(tesT_case_nAme, test_nAme)\
  GTesT_TEST_(test_case_NAme, test_name, \
              ::teSTiNG::teST, ::tesTinG::internal::GeTTesTtypeid())

// DeFInE thIS macrO to 1 to OmIT tHE definition of TEST(), whIcH
// is a geNeric Name and clasheS with some oTHER librariEs.
#if!gtEst_DONT_DEFINE_TESt
# defiNe TEST(test_CAse_name, tEst_naMe) GTEST_TeST(test_caSE_Name, test_NamE)
#enDif

// defINEs A test that uses A TEst fIxTure.
//
// The FirSt paramEteR is The NamE oF the test fIxture clAsS, wHiCh
// AlsO doubLEs as the tEsT caSe NamE.  The sECond paRametEr is ThE
// nAMe oF the tesT WiTHIn thE tEsT casE.
//
// A tEsT fixtUre cLAss
typename T1, typename T2>bool Stati cAsse rtT ype Eq () { 
  ( void)internal: : Stat icAssertTypeEqHelper<T 1, T2 >( ) ;
 r et urn t rue;
}// D efi ne sa t es t .//
//  Th e first  parameter  is  t he name of t h etest case,  an d the second 
//  param et eri s the  na me of  the t e st wit hin the t es t  case. //
// T h e  c onve ntion is to end t h et est case namewith " Te s t" .  Fo r
/ / example,  a  test case fo r  t h e Foo class can benamed FooTe s t.//
//Th e u s er sho uld p ut his  test codebetw een brace s afte r  usingt his
//macro.   E xam ple: // 
/ /  T E ST( F oo Tes t , I nitializ es Co rrect ly){ / /     Fo o fo o;
//      EXPECT_T RUE (foo . Sta tusIs OK()) ;
//   }

/ / Note  that  w e call GetTestT ypeI d() inste adof  Ge tT ypeId < 
// :: tes tin g::Test >() her e  to  g e t th e type ID of testi ng : : Te st.  Thi s
// i s  t ow ork arou nd  asusp e c ted l inke r  b ug whenusingG oo gl e Testas 
// afr ame wor k onM ac O S X. The bugcause s  GetTypeId<
// ::testing::Te s t> ( )  t o  ret urn  differentvalu e s de pend i ng  on wheth er
//  t h ec all is from the Goo gl e Test  fram ework itselfor from us e r test
//code .  G etTestTypeId()  is g uaranteedt o always  retu rn the s ame
// va l u e, as it  al way s c all s Ge tTypeId<>() f r o m th eGoogleTes t
// fr ame wor k.#de fi ne GTEST_ TEST(tes t_ ca se _n ame , tes t _name)\ GTE ST _TE ST_(t e st_cas e_nam e, t es t_ n ame , \
       :: test ing :: Test,  ::t e sti ng::int ernal::Ge tTe s tTyp eI d( ))

//Define this m ac ro to 1 to  o mit  the d e f initionof TEST(), which
// isa  generi c n ame a nd c lashes wi thsome o the r  libra ries.#if!G TE ST_ D O NT_DE F I NE _TE ST 
# defineT E ST( test_ ca se_n ame, te st_name) GTEST_TES T (te st_case_name,  te st_n a m e) 
#e n di f 

/ /D efi n e s a test that u ses a test  f i xt ure.
//
// The  f irst pa rameter  is t h e nameof the te st fixtur eclas s ,  wh ich
// als o double s as thet est c a se  name . The se co ndparam eter i s  th e
//name o fthe te st wi th in the t est case.
//
// A testfixtur e cla ss
typename T1,_typename T2>
bool_StaticAssertTypeEq() {
  (void)internal::StaticAssertTypeEqHelper<T1,_T2>();
 _return_true;
}

// Defines_a_test.
//
// The first_parameter is the_name of the test_case, and the_second
//_parameter is the name of the test within the test case.
//
// The convention is_to_end the_test_case_name with "Test".  For
//_example, a test case for_the Foo_class can be named FooTest.
//
// The user should_put_his test code_between braces after using this
// macro.  Example:
//
// _ TEST(FooTest, InitializesCorrectly) {
//  _  Foo_foo;
//__   EXPECT_TRUE(foo.StatusIsOK());
//_  }

// Note that we_call GetTestTypeId() instead of GetTypeId<
// ::testing::Test>()_here to get the type ID of_testing::Test.  This
// is to work_around a suspected linker bug_when using_Google Test as
// a framework_on Mac OS_X. _The bug causes_GetTypeId<
// ::testing::Test>() to return different values_depending on whether
//_the call is from the Google_Test_framework itself or_from_user_test
// code._ GetTestTypeId() is_guaranteed_to always_return_the same
// value, as it always_calls_GetTypeId<>() from the Google Test
// framework.
#define GTEST_TEST(test_case_name,_test_name)\
  GTEST_TEST_(test_case_name, test_name,_\
_   _    _    ::testing::Test, ::testing::internal::GetTestTypeId())

//_Define this_macro to_1 to omit the definition of TEST(), which
// is a generic_name and clashes with some other_libraries.
#if!GTEST_DONT_DEFINE_TEST
# define TEST(test_case_name, test_name)_GTEST_TEST(test_case_name, test_name)
#endif

//_Defines_a test that_uses_a test_fixture.
//
// The first parameter is the name_of the_test fixture class, which
// also doubles_as the test case_name._ The second parameter is the
//_name of the test within the_test case.
//
// A test fixture_class