ParseGoogleTestFlagsOnlyImpl implementation issue

[GoogleCodeExporter]

We can totaly remove the follow content in this function without break 
ParseGoogleTestFlagsOnlyImpl.

      // Yes.  Shift the remainder of the argv list left by one.  Note                                                      
      // that argv has (*argc + 1) elements, the last one always being                                                      
      // NULL.  The following loop moves the trailing NULL element as                                                       
      // well.                                                                                                              
      for (int j = i; j != *argc; j++) {                                                                                    
        argv[j] = argv[j + 1];                                                                                              
      }                                                                                                                     

      // Decrements the argument count.                                                                                     
      (*argc)--;                                                                                                            

      // We also need to decrement the iterator as we just removed                                                          
      // an element.                                                                                                        
      i--;

Original issue reported on code.google.com by xueyunlong@gmail.com on 12 Sep 2009 at 8:51

[GoogleCodeExporter]

This would be my new implementation of this function. It's more strait forward. 

template <typename CharType>                                                    

void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {                 

  for (int i = 1; i < *argc; i++) {                                                                                         
    const String arg_string = StreamableToString(argv[i]);                                                                  
    const char* const arg = arg_string.c_str();                                                                             

    using internal::ParseBoolFlag;                                                                                          
    using internal::ParseInt32Flag;                                                                                         
    using internal::ParseStringFlag;                                                                                        

    // Do we see a Google Test flag?                                                                                        
    if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,                                                                       
                      >EST_FLAG(also_run_disabled_tests)) ||                                                              
        ParseBoolFlag(arg, kBreakOnFailureFlag,                                                                             
                      >EST_FLAG(break_on_failure)) ||                                                                     
        ParseBoolFlag(arg, kCatchExceptionsFlag,                                                                            
                      >EST_FLAG(catch_exceptions)) ||                                                                     
        ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) ||                                                             
        ParseStringFlag(arg, kDeathTestStyleFlag,                                                                           
                        >EST_FLAG(death_test_style)) ||                                                                   
        ParseBoolFlag(arg, kDeathTestUseFork,                                                                               
                      >EST_FLAG(death_test_use_fork)) ||                                                                  
        ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) ||                                                           
        ParseStringFlag(arg, kInternalRunDeathTestFlag,                                                                     
                        >EST_FLAG(internal_run_death_test)) ||                                                            
        ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) ||                                                      
        ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) ||                                                           
        ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) ||                                                      
        ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) ||                                                   
        ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) ||                                                            
        ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) ||                                                           
        ParseBoolFlag(arg, kThrowOnFailureFlag, >EST_FLAG(throw_on_failure))                                              
        ) {                                                                                                                 
      ;                                                                                                                     
    } else if (arg_string == "--help" || arg_string == "-h" ||                                                              
               arg_string == "-?" || arg_string == "/?") {                                                                  
      g_help_flag = true;                                                                                                   
    }                                                                                                                       
  }                            

  if (g_help_flag) {                                                                                                        
    // We print the help here instead of in RUN_ALL_TESTS(), as the                                                         
    // latter may not be called at all if the user is using Google                                                          
    // Test with another testing framework.                                                                                 
    PrintColorEncoded(kColorEncodedHelpMessage);                                                                            
  }                                                                                                                         
}       

Original comment by xueyunlong@gmail.com on 12 Sep 2009 at 8:53

• Added labels: ****
• Removed labels: ****

[GoogleCodeExporter]

arg-shifting is the intended side effect here.  We want InitGoogleTest() to 
*remove* 
all gtest flags it finds from argv, such that the user can call another command 
line 
parser to process the non-gtest flags.

Original comment by zhanyong...@gmail.com on 15 Sep 2009 at 7:59

• Changed state: WontFix
• Added labels: Type-Other
• Removed labels: Type-Defect