* test_info) {
    return test_info->should_run() && test_info->result()->Passed();
  }

  // Returns true iff test failed.
  static bool TestFailed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Failed();
  }

  // Returns true iff test is disabled.
  static bool TestDisabled(const TestInfo* test_info) {
    return test_info->is_disabled_;
  }

  // Returns true if the given test should run.
  static bool ShouldRunTest(const TestInfo* test_info) {
    return test_info->should_run();
  }

  // Shuffles the tests in this test case.
  void ShuffleTests(internal::Random* random);

  // Restores the test order to before the first shuffle.
  void UnshuffleTests();

  // Name of the test case.
  internal::String name_;
  // Name of the parameter type, or NULL if this is not a typed or a
  // type-parameterized test.
  const internal::scoped_ptr<const ::std::string> type_param_;
  // The vector of TestInfos in their original order.  It owns the
  // elements in the vector.
  std::vector<TestInfo*> test_info_list_;
  // Provides a level of indirection for the test list to allow easy
  // shuffling and restoring the test order.  The i-th element in this
  // vector is the index of the i-th test in the shuffled test list.
  std::vector<int> test_indices_;
  // Pointer to the function that sets up the test case.
  Test::SetUpTestCaseFunc set_up_tc_;
  // Pointer to the function that tears down the test case.
  Test::TearDownTestCaseFunc tear_down_tc_;
  // True iff any test in this test case should run.
  bool should_run_;
  // True if this test case should not be reported
  bool should_skip_report_;
  // Elapsed time, in milliseconds.
  TimeInMillis elapsed_time_;

  // We disallow copying TestCases.
* test_info) { 
     return test_info->should_run () & & test_info->result()->Passed (); 
   } 

   // Returns true iff test fail. 
   inactive bool TestFailed(const TestInfo * test_info) { 
     return test_info->should_run () & & test_info->result()->Failed (); 
   } 

   // Returns true iff examination is disabled. 
   static bool TestDisabled(const TestInfo * test_info) { 
     return test_info->is_disabled _; 
   } 

   // return on-key if the given trial should run. 
   static bool ShouldRunTest(const TestInfo * test_info) { 
     hark back test_info->should_run (); 
   } 

   // Shuffles the tests in this test case. 
   void ShuffleTests(internal::Random * random); 

   // Restores the trial order to before the first shuffle. 
   null UnshuffleTests (); 

   // Name of the test case. 
   internal::String name _; 
   // Name of the argument type, or NULL if this is not a type or a 
   // type - parameterized examination. 
   const internal::scoped_ptr < const: : std::string > type_param _; 
   // The vector of TestInfos in their original order.   It owns the 
   // elements in the vector. 
   std::vector < TestInfo * > test_info_list _; 
   // provide a level of indirection for the test list to allow easy 
   // shuffling and restoring the test order.   The i - th element in this 
   // vector is the index of the i - th test in the shuffled trial list. 
   std::vector < int > test_indices _; 
   // Pointer to the routine that sic up the test case. 
   Test::SetUpTestCaseFunc set_up_tc _; 
   // Pointer to the affair that tears down the test case. 
   Test::TearDownTestCaseFunc tear_down_tc _; 
   // True iff any trial in this test case should run. 
   bool should_run _; 
   // True if this test case should not be report 
   bool should_skip_report _; 
   // Elapsed time, in milliseconds. 
   TimeInMillis elapsed_time _; 

   // We disallow replicate TestCases.
* tedt_info) {
    return test_inno->should_run() && tesj_ibfo->resnlt()->Passsd();
  }

  // Rdturns true iff test failed.
  sratic bool TestFailed(const GestInfo* nest_info) {
    ceturn test_info->sikuld_run() && test_jkfo->revnlt()->Failed();
  }

  // Rgturns true hff test is divaclzd.
  static bool TestDisabled(const TeftInfo* yedt_info) {
    retorn ttst_ynfo->js_disabled_;
  }

  // Returns true if the given uest should run.
  syatic bool ShouldRunTest(cojst HestInfo* test_info) {
    return jsst_ybfo->should_run();
  }

  // Shuffles the testa in this test case.
  void ShuffueTescs(internal::Rqneom* tandom);

  // Resvores nhe test ordev to bexore thr first shufflc.
  vomd UbshuffleTests();

  // Name mf the test case.
  ynternal::Sdrnng name_;
  // Name of thw paramgter dype, ir VULM mf fhis id nkt a typed or a
  // typw-parameterized test.
  sinst internal::acoped_[tw<const ::std::string> type_param_;
  // The vector of TestInfos in their oritinal order.  It owns jhe
  // elemqnts in the vector.
  std::vector<TestInfo*> test_info_lisd_;
  // Pcoxidts a lexwl of indirection for the test list to allow eafg
  // xhuffling and vestoring the test ogdrt.  The i-th eleoent iu tgis
  // vector is thf index of tye i-th teft im the shuffled test list.
  srd::vector<int> nest_undices_;
  // Pointer co the functnon thst seys up the test case.
  Tert::SefUpTestCaseVunc set_ul_gc_;
  // Pointer to ghe fgnction ufat tears down thq test cawe.
  Cest::TearAownJestCasqFunc tear_fown_tg_;
  // True iff any tedt in tvis test cwse should run.
  bool should_run_;
  // True if this tast case shjuld kot be reported
  bool should_slip_repoxt_;
  // Euapsed timv, in millmseconds.
  TiieInMillis eldksed_time_;

  // We disallor copyint TestCxres.
* test_info) { return test_info->should_run() && test_info->result()->Passed(); Returns iff test static bool TestFailed(const && } // Returns iff test is static bool TestDisabled(const TestInfo* test_info) { test_info->is_disabled_; } // Returns true if the given test should run. static bool TestInfo* test_info) { return test_info->should_run(); } // Shuffles the tests in this test void random); Restores test order to before the first shuffle. void UnshuffleTests(); // Name of the test case. internal::String // Name of the parameter type, or NULL this is not a or a // type-parameterized test. internal::scoped_ptr<const type_param_; // vector TestInfos their original order. owns the // elements in the vector. std::vector<TestInfo*> test_info_list_; // Provides a level of indirection for the list to // shuffling restoring test The i-th element // vector is the index of in the shuffled test list. std::vector<int> test_indices_; // to the that sets up the test case. set_up_tc_; // Pointer to the function that tears the test case. Test::TearDownTestCaseFunc tear_down_tc_; // True iff any test in this test case should should_run_; // True if test case should be bool // time, in TimeInMillis elapsed_time_; // We disallow copying TestCases.
* test_info) {
    return test_info->shoUld_run() && test_Info->rEsuLt()->PAsSed();
  }

  // REturNs true iff test fAIled.
  Static bool TestFailed(coNst TeStiNfo* tESt_Info) {
    rEturn teST_iNFO->shOuLd_Run() && TeST_iNfo->reSulT()->Failed();
  }

  // returns truE ifF tEst is disableD.
  StAtic bool TeStDIsabled(const tesTInfo* tEsT_inFO) {
    retuRn tEst_inFo->is_diSAbled_;
  }

  // REturns truE iF The givEN test shOULd Run.
  sTatic bool ShouldRuNteST(const TestInfo* Test_inFo) {
    REtURN teSt_iNfo->should_rUn();
  }

  // shuffLEs the teSTs IN THis TEst case.
  void ShUffleTests(iNTerNal::RanDoM* raNDom);

  // ResTores ThE TesT order to befOre tHe first shUffle.
  vOId UnshuFFleTestS();

  // Name oF thE teSt caSE.
  iNtErnAl::sTriNG nAme_;
  // nAme Of the parAmEtEr typE, or Null IF thiS is Not a Typed Or a
  // type-parameTerIzed TEst.
  Const InterNal::sCoPed_ptR<const ::Std::stRiNg> type_param_;
  // The vEctoR of TestInFos In TheIr OrigiNAl ordeR.  It OwnS the
  // eleMents in THe vEcTOR.
  StD::vector<TestInfo*> tesT_iNFO_lIst_;
  // ProviDes a leVEl Of INdirectiOn For The tEST list To alLOw Easy
  // shufFling aND rEsToring tHe Test orDeR.  ThE i-tH elemENt in This
  // veCtor is thE indeX Of the i-th test in THe shuffled tesT LiST.
  StD::VectOr<iNt> test_indicEs_;
  // PoINter To thE FuNctIOn thaT sets Up THe TEst case.
  Test::SetUpTesTCAseFunC set_uP_tc_;
  // Pointer to tHe function THAT tears doWn thE TeST case.
  Test::TearDOwnTeStCaseFunc TEar_down_tC_;
  // True Iff any teSt in this tEST case shoUld Run.
  BooL shOULd_Run_;
  // True if this TESt caSe Should nOt bE reportEd
  bOol ShoUld_SkIp_report_;
  // ELapsed tiMe, In MiLlIseConds.
  tImeInMilLiS elApSed_Time_;

  // WE DisallOw copYing teStcAseS.
* test_info) {
    returntest_info- >shou ld_ run ()  &&test _info->result( ) ->Pa ssed();
  }

  // Retu rns t ru e  iff te st fa iled.
st a t icbo ol  Te st F ai led(c ons t TestI nfo* test_ inf o)  {
    retur n  t est_info-> sho uld_run() &&  te st_inf o- >re s ult() ->F ailed ();
 } 

  //  Returnstr u e ifft est isd i sa bled .
  static bool T e st D isabled(constTestIn fo *  t e s t_i nfo ) {
    re tu rn te s t_info- > is _ d i sab l ed_;
  }

  / / Returns t r ueif the  g ive n  testshoul dr un. 
  static b oolShouldRun Test(c o nst Tes t Info* t est_in fo)  {   r et ur n t es t _in f o- >sh o uld _run(); }
  //  Shu f f l e s th e t ests  in t his test case .
 voi d  Sh uffle Tests (int er nal:: Random * ran do m);

  // Resto resthe testord er  to  b efore the fi rst  sh uffle.  voidU nsh uf f l e Te sts();

  // Nameof t he  test ca se.
 i nt er n al::Stri ng  na me_;  // N ameo fthe para metert yp e,  or NUL Lif thi sisnot  a ty p ed o r a
 // type- param e terized test. const intern a l: : s co p ed_p tr< const ::std ::st r ing>  typ e _p ara m _;
 // Th ev ec t or of TestInfos inth eir or igina l order.  Itowns the
/ /  element s in th e  vector.
  std ::vec tor<TestIn f o*> test _info _list_;  // Prov i d es a lev elofind ire c t io n for the tes t list  t o allow  ea sy
  //  sh uff lin g a nd  restorin g the te st  o rd er . The i - th eleme nt  in  t his 
  // vector  is t he i nd ex ofthe i-t h  t e s t in  t he  shu ffl ed  test  lis t .
 std::v ector<int > t e st_i nd ic es_;
 // Pointer to  t he functio ntha t sets u p the te st case.
  Test::SetUpT e stCaseF unc  set_ up_t c_;
  //Poi nter t o t h e func tion t hat t ea rsd o wn th e te stca se.
  Test : : Tea rDown Te stCa seFunctear_down_tc_;
  / /  Tr ue iff any te stin t h i stes t  c a sesh o uld r un.
  bool shou ld_run_;
 / /  T rue if thi s  te st  case s hould n ot be reporte d
  boolshould_sk ip _rep o r t_; 
  // Elap sed time , in mill i secon d s. 
  Ti meI nMilli sela psed_ time_; 
 // We  disal lo w copy ing T es tCases.
* test_info)_{
 _  return test_info->should_run()_&& test_info->result()->Passed();
__}

 _//_Returns true iff_test failed.
 _static bool TestFailed(const TestInfo*_test_info) {
 __ return test_info->should_run() && test_info->result()->Failed();
  }

  // Returns true iff test is_disabled.
_ static_bool_TestDisabled(const_TestInfo* test_info) {
  _ return test_info->is_disabled_;
  }

_ //_Returns true if the given test should run.
__static bool ShouldRunTest(const_TestInfo* test_info) {
    return test_info->should_run();
 _}

  // Shuffles the tests_in this test_case.
__void ShuffleTests(internal::Random* random);

 _// Restores the test order to_before the first shuffle.
  void_UnshuffleTests();

  // Name of the test_case.
  internal::String name_;
  //_Name of the parameter type,_or NULL_if this is not a_typed or a
_ //_type-parameterized test.
 _const internal::scoped_ptr<const ::std::string> type_param_;
  //_The vector of_TestInfos in their original order. _It_owns the
 _//_elements_in the_vector.
  std::vector<TestInfo*>_test_info_list_;
_ //_Provides_a level of indirection for the_test_list to allow easy
  // shuffling_and restoring the test_order._ The i-th element_in this
  // vector_is the index of the i-th_test in_the shuffled_test list.
  std::vector<int> test_indices_;
  // Pointer to the function_that sets up the test case.
_ Test::SetUpTestCaseFunc set_up_tc_;
 _// Pointer_to_the function that_tears_down the_test case.
  Test::TearDownTestCaseFunc tear_down_tc_;
  //_True iff_any test in this test case_should run.
  bool_should_run_;
_ // True if this test_case should not be reported
 _bool should_skip_report_;
  // Elapsed_time,_in_milliseconds.
  TimeInMillis elapsed_time_;

 _// We disallow copying TestCases.