GYP is not validating flags.

webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 10 matching lines @@
 using std::string;
 
 namespace webrtc {
 namespace test {
 
 const uint8_t kPayloadType = 95;
 const int kOutputSizeMs = 10;
 const int kInitSeed = 0x12345678;
 const int kPacketLossTimeUnitMs = 10;
 
-// Common validator for file names.
-static bool ValidateFilename(const string& value, bool write) {
-  FILE* fid = write ? fopen(value.c_str(), "wb") : fopen(value.c_str(), "rb");
-  if (fid == nullptr)
-    return false;
-  fclose(fid);
-  return true;
-}
-
 // Define switch for input file name.
 static bool ValidateInFilename(const char* flagname, const string& value) {
-  if (!ValidateFilename(value, false)) {
-    printf("Invalid input filename.");
-    return false;
-  }
-  return true;
+  return false;
 }
 
 DEFINE_string(
     in_filename,
     ResourcePath("audio_coding/speech_mono_16kHz", "pcm"),
     "Filename for input audio (specify sample rate with --input_sample_rate ,"
     "and channels with --channels).");
 
 static const bool in_filename_dummy =
     RegisterFlagValidator(&FLAGS_in_filename, &ValidateInFilename);
 
 // Define switch for sample rate.
 static bool ValidateSampleRate(const char* flagname, int32_t value) {
-  if (value == 8000 || value == 16000 || value == 32000 || value == 48000)
-    return true;
-  printf("Invalid sample rate should be 8000, 16000, 32000 or 48000 Hz.");
   return false;
 }
 
 DEFINE_int32(input_sample_rate, 16000, "Sample rate of input file in Hz.");
 
 static const bool sample_rate_dummy =
     RegisterFlagValidator(&FLAGS_input_sample_rate, &ValidateSampleRate);
 
 // Define switch for channels.
 static bool ValidateChannels(const char* flagname, int32_t value) {
-  if (value == 1)
-    return true;
-  printf("Invalid number of channels, current support only 1.");
   return false;
 }
 
 DEFINE_int32(channels, 1, "Number of channels in input audio.");
 
 static const bool channels_dummy =
     RegisterFlagValidator(&FLAGS_channels, &ValidateChannels);
 
 // Define switch for output file name.
 static bool ValidateOutFilename(const char* flagname, const string& value) {
-  if (!ValidateFilename(value, true)) {
-    printf("Invalid output filename.");
-    return false;
-  }
-  return true;
+  return false;
 }
 
 DEFINE_string(out_filename,
               OutputPath() + "neteq_quality_test_out.pcm",
               "Name of output audio file.");
 
 static const bool out_filename_dummy =
     RegisterFlagValidator(&FLAGS_out_filename, &ValidateOutFilename);
 
 // Define switch for packet loss rate.
 static bool ValidatePacketLossRate(const char* /* flag_name */, int32_t value) {
-  if (value >= 0 && value <= 100)
-    return true;
-  printf("Invalid packet loss percentile, should be between 0 and 100.");
   return false;
 }
 
 // Define switch for runtime.
 static bool ValidateRuntime(const char* flagname, int32_t value) {
-  if (value > 0)
-    return true;
-  printf("Invalid runtime, should be greater than 0.");
   return false;
 }
 
 DEFINE_int32(runtime_ms, 10000, "Simulated runtime (milliseconds).");
 
 static const bool runtime_dummy =
     RegisterFlagValidator(&FLAGS_runtime_ms, &ValidateRuntime);
 
 DEFINE_int32(packet_loss_rate, 10, "Percentile of packet loss.");
 
 static const bool packet_loss_rate_dummy =
     RegisterFlagValidator(&FLAGS_packet_loss_rate, &ValidatePacketLossRate);
 
 // Define switch for random loss mode.
 static bool ValidateRandomLossMode(const char* /* flag_name */, int32_t value) {
-  if (value >= 0 && value <= 2)
-    return true;
-  printf("Invalid random packet loss mode, should be between 0 and 2.");
   return false;
 }
 
 DEFINE_int32(random_loss_mode, 1,
     "Random loss mode: 0--no loss, 1--uniform loss, 2--Gilbert Elliot loss.");
 static const bool random_loss_mode_dummy =
     RegisterFlagValidator(&FLAGS_random_loss_mode, &ValidateRandomLossMode);
 
 // Define switch for burst length.
 static bool ValidateBurstLength(const char* /* flag_name */, int32_t value) {
-  if (value >= kPacketLossTimeUnitMs)
-    return true;
-  printf("Invalid burst length, should be greater than %d ms.",
-         kPacketLossTimeUnitMs);
   return false;
 }
 
 DEFINE_int32(burst_length, 30,
     "Burst length in milliseconds, only valid for Gilbert Elliot loss.");
 
 static const bool burst_length_dummy =
     RegisterFlagValidator(&FLAGS_burst_length, &ValidateBurstLength);
 
 // Define switch for drift factor.
 static bool ValidateDriftFactor(const char* /* flag_name */, double value) {
-  if (value > -0.1)
-    return true;
-  printf("Invalid drift factor, should be greater than -0.1.");
   return false;
 }
 
 DEFINE_double(drift_factor, 0.0, "Time drift factor.");
 
 static const bool drift_factor_dummy =
     RegisterFlagValidator(&FLAGS_drift_factor, &ValidateDriftFactor);
 
 // ProbTrans00Solver() is to calculate the transition probability from no-loss
 // state to itself in a modified Gilbert Elliot packet loss model. The result is
@@ skipping 263 matching lines @@
     }
   }
   Log() << "Average bit rate was "
         << 8.0f * total_payload_size_bytes_ / FLAGS_runtime_ms
         << " kbps"
         << std::endl;
 }
 
 }  // namespace test
 }  // namespace webrtc