cmdline/cmdline_parser_test.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "cmdline_parser.h"
 #include "runtime/runtime_options.h"
 #include "runtime/parsed_options.h"

 #include "utils.h"
 #include <numeric>
 #include "gtest/gtest.h"
 #include "runtime/experimental_flags.h"

 #define EXPECT_NULL(expected) EXPECT_EQ(reinterpret_cast<const void*>(expected), \
                                         reinterpret_cast<void*>(nullptr));

 namespace art {
   bool UsuallyEquals(double expected, double actual);

   // This has a gtest dependency, which is why it's in the gtest only.
   bool operator==(const TestProfilerOptions& lhs, const TestProfilerOptions& rhs) {
     return lhs.enabled_ == rhs.enabled_ &&
         lhs.output_file_name_ == rhs.output_file_name_ &&
         lhs.period_s_ == rhs.period_s_ &&
         lhs.duration_s_ == rhs.duration_s_ &&
         lhs.interval_us_ == rhs.interval_us_ &&
         UsuallyEquals(lhs.backoff_coefficient_, rhs.backoff_coefficient_) &&
         UsuallyEquals(lhs.start_immediately_, rhs.start_immediately_) &&
         UsuallyEquals(lhs.top_k_threshold_, rhs.top_k_threshold_) &&
         UsuallyEquals(lhs.top_k_change_threshold_, rhs.top_k_change_threshold_) &&
         lhs.profile_type_ == rhs.profile_type_ &&
         lhs.max_stack_depth_ == rhs.max_stack_depth_;
   }

   bool UsuallyEquals(double expected, double actual) {
     using FloatingPoint = ::testing::internal::FloatingPoint<double>;

     FloatingPoint exp(expected);
     FloatingPoint act(actual);

     // Compare with ULPs instead of comparing with ==
     return exp.AlmostEquals(act);
   }

   template <typename T>
   bool UsuallyEquals(const T& expected, const T& actual,
                      typename std::enable_if<
                          detail::SupportsEqualityOperator<T>::value>::type* = 0) {
     return expected == actual;
   }

   // Try to use memcmp to compare simple plain-old-data structs.
   //
   // This should *not* generate false positives, but it can generate false negatives.
   // This will mostly work except for fields like float which can have different bit patterns
   // that are nevertheless equal.
   // If a test is failing because the structs aren't "equal" when they really are
   // then it's recommended to implement operator== for it instead.
   template <typename T, typename ... Ignore>
   bool UsuallyEquals(const T& expected, const T& actual,
                      const Ignore& ... more ATTRIBUTE_UNUSED,
                      typename std::enable_if<std::is_pod<T>::value>::type* = 0,
                      typename std::enable_if<!detail::SupportsEqualityOperator<T>::value>::type* = 0
                      ) {
     return memcmp(std::addressof(expected), std::addressof(actual), sizeof(T)) == 0;
   }

   bool UsuallyEquals(const XGcOption& expected, const XGcOption& actual) {
     return memcmp(std::addressof(expected), std::addressof(actual), sizeof(expected)) == 0;
   }

   bool UsuallyEquals(const char* expected, std::string actual) {
     return std::string(expected) == actual;
   }

   template <typename TMap, typename TKey, typename T>
   ::testing::AssertionResult IsExpectedKeyValue(const T& expected,
                                                 const TMap& map,
                                                 const TKey& key) {
     auto* actual = map.Get(key);
     if (actual != nullptr) {
       if (!UsuallyEquals(expected, *actual)) {
         return ::testing::AssertionFailure()
           << "expected " << detail::ToStringAny(expected) << " but got "
           << detail::ToStringAny(*actual);
       }
       return ::testing::AssertionSuccess();
     }

     return ::testing::AssertionFailure() << "key was not in the map";
   }

   template <typename TMap, typename TKey, typename T>
   ::testing::AssertionResult IsExpectedDefaultKeyValue(const T& expected,
                                                        const TMap& map,
                                                        const TKey& key) {
     const T& actual = map.GetOrDefault(key);
     if (!UsuallyEquals(expected, actual)) {
       return ::testing::AssertionFailure()
           << "expected " << detail::ToStringAny(expected) << " but got "
           << detail::ToStringAny(actual);
      }
     return ::testing::AssertionSuccess();
   }

 class CmdlineParserTest : public ::testing::Test {
  public:
   CmdlineParserTest() = default;
   ~CmdlineParserTest() = default;

  protected:
   using M = RuntimeArgumentMap;
   using RuntimeParser = ParsedOptions::RuntimeParser;

   static void SetUpTestCase() {
     art::InitLogging(nullptr);  // argv = null
   }

   virtual void SetUp() {
     parser_ = ParsedOptions::MakeParser(false);  // do not ignore unrecognized options
   }

   static ::testing::AssertionResult IsResultSuccessful(CmdlineResult result) {
     if (result.IsSuccess()) {
       return ::testing::AssertionSuccess();
     } else {
       return ::testing::AssertionFailure()
         << result.GetStatus() << " with: " << result.GetMessage();
     }
   }

   static ::testing::AssertionResult IsResultFailure(CmdlineResult result,
                                                     CmdlineResult::Status failure_status) {
     if (result.IsSuccess()) {
       return ::testing::AssertionFailure() << " got success but expected failure: "
           << failure_status;
     } else if (result.GetStatus() == failure_status) {
       return ::testing::AssertionSuccess();
     }

     return ::testing::AssertionFailure() << " expected failure " << failure_status
         << " but got " << result.GetStatus();
   }

   std::unique_ptr<RuntimeParser> parser_;
 };

 #define EXPECT_KEY_EXISTS(map, key) EXPECT_TRUE((map).Exists(key))
 #define EXPECT_KEY_VALUE(map, key, expected) EXPECT_TRUE(IsExpectedKeyValue(expected, map, key))
 #define EXPECT_DEFAULT_KEY_VALUE(map, key, expected) EXPECT_TRUE(IsExpectedDefaultKeyValue(expected, map, key))

 #define _EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv)              \
   do {                                                        \
     EXPECT_TRUE(IsResultSuccessful(parser_->Parse(argv)));    \
     EXPECT_EQ(0u, parser_->GetArgumentsMap().Size());         \

 #define EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv)               \
   _EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv);                   \
   } while (false)

 #define EXPECT_SINGLE_PARSE_DEFAULT_VALUE(expected, argv, key)\
   _EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv);                   \
     RuntimeArgumentMap args = parser_->ReleaseArgumentsMap(); \
     EXPECT_DEFAULT_KEY_VALUE(args, key, expected);            \
   } while (false)                                             // NOLINT [readability/namespace] [5]

 #define _EXPECT_SINGLE_PARSE_EXISTS(argv, key)                \
   do {                                                        \
     EXPECT_TRUE(IsResultSuccessful(parser_->Parse(argv)));    \
     RuntimeArgumentMap args = parser_->ReleaseArgumentsMap(); \
     EXPECT_EQ(1u, args.Size());                               \
     EXPECT_KEY_EXISTS(args, key);                             \

 #define EXPECT_SINGLE_PARSE_EXISTS(argv, key)                 \
     _EXPECT_SINGLE_PARSE_EXISTS(argv, key);                   \
   } while (false)

 #define EXPECT_SINGLE_PARSE_VALUE(expected, argv, key)        \
     _EXPECT_SINGLE_PARSE_EXISTS(argv, key);                   \
     EXPECT_KEY_VALUE(args, key, expected);                    \
   } while (false)                                             // NOLINT [readability/namespace] [5]

 #define EXPECT_SINGLE_PARSE_VALUE_STR(expected, argv, key)    \
   EXPECT_SINGLE_PARSE_VALUE(std::string(expected), argv, key)

 #define EXPECT_SINGLE_PARSE_FAIL(argv, failure_status)         \
     do {                                                       \
       EXPECT_TRUE(IsResultFailure(parser_->Parse(argv), failure_status));\
       RuntimeArgumentMap args = parser_->ReleaseArgumentsMap();\
       EXPECT_EQ(0u, args.Size());                              \
     } while (false)

 TEST_F(CmdlineParserTest, TestSimpleSuccesses) {
   auto& parser = *parser_;

   EXPECT_LT(0u, parser.CountDefinedArguments());

   {
     // Test case 1: No command line arguments
     EXPECT_TRUE(IsResultSuccessful(parser.Parse("")));
     RuntimeArgumentMap args = parser.ReleaseArgumentsMap();
     EXPECT_EQ(0u, args.Size());
   }

   EXPECT_SINGLE_PARSE_EXISTS("-Xzygote", M::Zygote);
   EXPECT_SINGLE_PARSE_VALUE_STR("/hello/world", "-Xbootclasspath:/hello/world", M::BootClassPath);
   EXPECT_SINGLE_PARSE_VALUE("/hello/world", "-Xbootclasspath:/hello/world", M::BootClassPath);
   EXPECT_SINGLE_PARSE_VALUE(Memory<1>(234), "-Xss234", M::StackSize);
   EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(1234*MB), "-Xms1234m", M::MemoryInitialSize);
   EXPECT_SINGLE_PARSE_VALUE(true, "-XX:EnableHSpaceCompactForOOM", M::EnableHSpaceCompactForOOM);
   EXPECT_SINGLE_PARSE_VALUE(false, "-XX:DisableHSpaceCompactForOOM", M::EnableHSpaceCompactForOOM);
   EXPECT_SINGLE_PARSE_VALUE(0.5, "-XX:HeapTargetUtilization=0.5", M::HeapTargetUtilization);
   EXPECT_SINGLE_PARSE_VALUE(5u, "-XX:ParallelGCThreads=5", M::ParallelGCThreads);
   EXPECT_SINGLE_PARSE_EXISTS("-Xno-dex-file-fallback", M::NoDexFileFallback);
 }  // TEST_F

 TEST_F(CmdlineParserTest, TestSimpleFailures) {
   // Test argument is unknown to the parser
   EXPECT_SINGLE_PARSE_FAIL("abcdefg^%@#*(@#", CmdlineResult::kUnknown);
   // Test value map substitution fails
   EXPECT_SINGLE_PARSE_FAIL("-Xverify:whatever", CmdlineResult::kFailure);
   // Test value type parsing failures
   EXPECT_SINGLE_PARSE_FAIL("-Xsswhatever", CmdlineResult::kFailure);  // invalid memory value
   EXPECT_SINGLE_PARSE_FAIL("-Xms123", CmdlineResult::kFailure);       // memory value too small
   EXPECT_SINGLE_PARSE_FAIL("-XX:HeapTargetUtilization=0.0", CmdlineResult::kOutOfRange);  // toosmal
   EXPECT_SINGLE_PARSE_FAIL("-XX:HeapTargetUtilization=2.0", CmdlineResult::kOutOfRange);  // toolarg
   EXPECT_SINGLE_PARSE_FAIL("-XX:ParallelGCThreads=-5", CmdlineResult::kOutOfRange);  // too small
   EXPECT_SINGLE_PARSE_FAIL("-Xgc:blablabla", CmdlineResult::kUsage);  // not a valid suboption
 }  // TEST_F

 TEST_F(CmdlineParserTest, TestLogVerbosity) {
   {
     const char* log_args = "-verbose:"
         "class,compiler,gc,heap,jdwp,jni,monitor,profiler,signals,startup,third-party-jni,"
         "threads,verifier";

     LogVerbosity log_verbosity = LogVerbosity();
     log_verbosity.class_linker = true;
     log_verbosity.compiler = true;
     log_verbosity.gc = true;
     log_verbosity.heap = true;
     log_verbosity.jdwp = true;
     log_verbosity.jni = true;
     log_verbosity.monitor = true;
     log_verbosity.profiler = true;
     log_verbosity.signals = true;
     log_verbosity.startup = true;
     log_verbosity.third_party_jni = true;
     log_verbosity.threads = true;
     log_verbosity.verifier = true;

     EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
   }

   {
     const char* log_args = "-verbose:"
         "class,compiler,gc,heap,jdwp,jni,monitor";

     LogVerbosity log_verbosity = LogVerbosity();
     log_verbosity.class_linker = true;
     log_verbosity.compiler = true;
     log_verbosity.gc = true;
     log_verbosity.heap = true;
     log_verbosity.jdwp = true;
     log_verbosity.jni = true;
     log_verbosity.monitor = true;

     EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
   }

   EXPECT_SINGLE_PARSE_FAIL("-verbose:blablabla", CmdlineResult::kUsage);  // invalid verbose opt

   {
     const char* log_args = "-verbose:deopt";
     LogVerbosity log_verbosity = LogVerbosity();
     log_verbosity.deopt = true;
     EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
   }

   {
     const char* log_args = "-verbose:oat";
     LogVerbosity log_verbosity = LogVerbosity();
     log_verbosity.oat = true;
     EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
   }
 }  // TEST_F

 // TODO: Enable this b/19274810
 TEST_F(CmdlineParserTest, DISABLED_TestXGcOption) {
   /*
    * Test success
    */
   {
     XGcOption option_all_true{};  // NOLINT [readability/braces] [4]
     option_all_true.collector_type_ = gc::CollectorType::kCollectorTypeCMS;
     option_all_true.verify_pre_gc_heap_ = true;
     option_all_true.verify_pre_sweeping_heap_ = true;
     option_all_true.verify_post_gc_heap_ = true;
     option_all_true.verify_pre_gc_rosalloc_ = true;
     option_all_true.verify_pre_sweeping_rosalloc_ = true;
     option_all_true.verify_post_gc_rosalloc_ = true;

     const char * xgc_args_all_true = "-Xgc:concurrent,"
         "preverify,presweepingverify,postverify,"
         "preverify_rosalloc,presweepingverify_rosalloc,"
         "postverify_rosalloc,precise,"
         "verifycardtable";

     EXPECT_SINGLE_PARSE_VALUE(option_all_true, xgc_args_all_true, M::GcOption);

     XGcOption option_all_false{};  // NOLINT [readability/braces] [4]
     option_all_false.collector_type_ = gc::CollectorType::kCollectorTypeMS;
     option_all_false.verify_pre_gc_heap_ = false;
     option_all_false.verify_pre_sweeping_heap_ = false;
     option_all_false.verify_post_gc_heap_ = false;
     option_all_false.verify_pre_gc_rosalloc_ = false;
     option_all_false.verify_pre_sweeping_rosalloc_ = false;
     option_all_false.verify_post_gc_rosalloc_ = false;

     const char* xgc_args_all_false = "-Xgc:nonconcurrent,"
         "nopreverify,nopresweepingverify,nopostverify,nopreverify_rosalloc,"
         "nopresweepingverify_rosalloc,nopostverify_rosalloc,noprecise,noverifycardtable";

     EXPECT_SINGLE_PARSE_VALUE(option_all_false, xgc_args_all_false, M::GcOption);

     XGcOption option_all_default{};  // NOLINT [readability/braces] [4]

     const char* xgc_args_blank = "-Xgc:";
     EXPECT_SINGLE_PARSE_VALUE(option_all_default, xgc_args_blank, M::GcOption);
   }

   /*
    * Test failures
    */
   EXPECT_SINGLE_PARSE_FAIL("-Xgc:blablabla", CmdlineResult::kUsage);  // invalid Xgc opt
 }  // TEST_F

 /*
  * {"-Xrunjdwp:_", "-agentlib:jdwp=_"}
  */
 TEST_F(CmdlineParserTest, TestJdwpOptions) {
   /*
    * Test success
    */
   {
     /*
      * "Example: -Xrunjdwp:transport=dt_socket,address=8000,server=y\n"
      */
     JDWP::JdwpOptions opt = JDWP::JdwpOptions();
     opt.transport = JDWP::JdwpTransportType::kJdwpTransportSocket;
     opt.port = 8000;
     opt.server = true;

     const char *opt_args = "-Xrunjdwp:transport=dt_socket,address=8000,server=y";

     EXPECT_SINGLE_PARSE_VALUE(opt, opt_args, M::JdwpOptions);
   }

   {
     /*
      * "Example: -agentlib:jdwp=transport=dt_socket,address=localhost:6500,server=n\n");
      */
     JDWP::JdwpOptions opt = JDWP::JdwpOptions();
     opt.transport = JDWP::JdwpTransportType::kJdwpTransportSocket;
     opt.host = "localhost";
     opt.port = 6500;
     opt.server = false;

     const char *opt_args = "-agentlib:jdwp=transport=dt_socket,address=localhost:6500,server=n";

     EXPECT_SINGLE_PARSE_VALUE(opt, opt_args, M::JdwpOptions);
   }

   /*
    * Test failures
    */
   EXPECT_SINGLE_PARSE_FAIL("-Xrunjdwp:help", CmdlineResult::kUsage);  // usage for help only
   EXPECT_SINGLE_PARSE_FAIL("-Xrunjdwp:blabla", CmdlineResult::kFailure);  // invalid subarg
   EXPECT_SINGLE_PARSE_FAIL("-agentlib:jdwp=help", CmdlineResult::kUsage);  // usage for help only
   EXPECT_SINGLE_PARSE_FAIL("-agentlib:jdwp=blabla", CmdlineResult::kFailure);  // invalid subarg
 }  // TEST_F

 /*
  * -D_ -D_ -D_ ...
  */
 TEST_F(CmdlineParserTest, TestPropertiesList) {
   /*
    * Test successes
    */
   {
     std::vector<std::string> opt = {"hello"};

     EXPECT_SINGLE_PARSE_VALUE(opt, "-Dhello", M::PropertiesList);
   }

   {
     std::vector<std::string> opt = {"hello", "world"};

     EXPECT_SINGLE_PARSE_VALUE(opt, "-Dhello -Dworld", M::PropertiesList);
   }

   {
     std::vector<std::string> opt = {"one", "two", "three"};

     EXPECT_SINGLE_PARSE_VALUE(opt, "-Done -Dtwo -Dthree", M::PropertiesList);
   }
 }  // TEST_F

 /*
 * -Xcompiler-option foo -Xcompiler-option bar ...
 */
 TEST_F(CmdlineParserTest, TestCompilerOption) {
  /*
   * Test successes
   */
   {
     std::vector<std::string> opt = {"hello"};
     EXPECT_SINGLE_PARSE_VALUE(opt, "-Xcompiler-option hello", M::CompilerOptions);
   }

   {
     std::vector<std::string> opt = {"hello", "world"};
     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xcompiler-option hello -Xcompiler-option world",
                               M::CompilerOptions);
   }

   {
     std::vector<std::string> opt = {"one", "two", "three"};
     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xcompiler-option one -Xcompiler-option two -Xcompiler-option three",
                               M::CompilerOptions);
   }
 }  // TEST_F

 /*
 * -Xjit, -Xnojit, -Xjitcodecachesize, Xjitcompilethreshold
 */
 TEST_F(CmdlineParserTest, TestJitOptions) {
  /*
   * Test successes
   */
   {
     EXPECT_SINGLE_PARSE_VALUE(true, "-Xusejit:true", M::UseJIT);
     EXPECT_SINGLE_PARSE_VALUE(false, "-Xusejit:false", M::UseJIT);
   }
   {
     EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(16 * KB), "-Xjitcodecachesize:16K", M::JITCodeCacheCapacity);
     EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(16 * MB), "-Xjitcodecachesize:16M", M::JITCodeCacheCapacity);
   }
   {
     EXPECT_SINGLE_PARSE_VALUE(12345u, "-Xjitthreshold:12345", M::JITCompileThreshold);
   }
 }  // TEST_F

 /*
 * -X-profile-*
 */
 TEST_F(CmdlineParserTest, TestProfilerOptions) {
  /*
   * Test successes
   */

   {
     TestProfilerOptions opt;
     opt.enabled_ = true;

     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xenable-profiler",
                               M::ProfilerOpts);
   }

   {
     TestProfilerOptions opt;
     // also need to test 'enabled'
     opt.output_file_name_ = "hello_world.txt";

     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xprofile-filename:hello_world.txt ",
                               M::ProfilerOpts);
   }

   {
     TestProfilerOptions opt = TestProfilerOptions();
     // also need to test 'enabled'
     opt.output_file_name_ = "output.txt";
     opt.period_s_ = 123u;
     opt.duration_s_ = 456u;
     opt.interval_us_ = 789u;
     opt.backoff_coefficient_ = 2.0;
     opt.start_immediately_ = true;
     opt.top_k_threshold_ = 50.0;
     opt.top_k_change_threshold_ = 60.0;
     opt.profile_type_ = kProfilerMethod;
     opt.max_stack_depth_ = 1337u;

     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xprofile-filename:output.txt "
                               "-Xprofile-period:123 "
                               "-Xprofile-duration:456 "
                               "-Xprofile-interval:789 "
                               "-Xprofile-backoff:2.0 "
                               "-Xprofile-start-immediately "
                               "-Xprofile-top-k-threshold:50.0 "
                               "-Xprofile-top-k-change-threshold:60.0 "
                               "-Xprofile-type:method "
                               "-Xprofile-max-stack-depth:1337",
                               M::ProfilerOpts);
   }

   {
     TestProfilerOptions opt = TestProfilerOptions();
     opt.profile_type_ = kProfilerBoundedStack;

     EXPECT_SINGLE_PARSE_VALUE(opt,
                               "-Xprofile-type:stack",
                               M::ProfilerOpts);
   }
 }  // TEST_F

 /* -Xexperimental:_ */
 TEST_F(CmdlineParserTest, TestExperimentalFlags) {
   // Off by default
   EXPECT_SINGLE_PARSE_DEFAULT_VALUE(ExperimentalFlags::kNone,
                                     "",
                                     M::Experimental);

   // Disabled explicitly
   EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kNone,
                             "-Xexperimental:none",
                             M::Experimental);

   // Enabled explicitly
   EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kLambdas,
                             "-Xexperimental:lambdas",
                             M::Experimental);
   // Enabled explicitly
   EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kDefaultMethods,
                             "-Xexperimental:default-methods",
                             M::Experimental);

   // Enabled both
   EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kDefaultMethods | ExperimentalFlags::kLambdas,
                             "-Xexperimental:default-methods "
                             "-Xexperimental:lambdas",
                             M::Experimental);
 }

 // -Xverify:_
 TEST_F(CmdlineParserTest, TestVerify) {
   EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kNone,     "-Xverify:none",     M::Verify);
   EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kEnable,   "-Xverify:remote",   M::Verify);
   EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kEnable,   "-Xverify:all",      M::Verify);
   EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kSoftFail, "-Xverify:softfail", M::Verify);
 }

 TEST_F(CmdlineParserTest, TestIgnoreUnrecognized) {
   RuntimeParser::Builder parserBuilder;

   parserBuilder
       .Define("-help")
           .IntoKey(M::Help)
       .IgnoreUnrecognized(true);

   parser_.reset(new RuntimeParser(parserBuilder.Build()));

   EXPECT_SINGLE_PARSE_EMPTY_SUCCESS("-non-existent-option");
   EXPECT_SINGLE_PARSE_EMPTY_SUCCESS("-non-existent-option1 --non-existent-option-2");
 }  //  TEST_F

 TEST_F(CmdlineParserTest, TestIgnoredArguments) {
   std::initializer_list<const char*> ignored_args = {
       "-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa",
       "-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:abdef",
       "-Xdexopt:foobar", "-Xnoquithandler", "-Xjnigreflimit:ixnay", "-Xgenregmap", "-Xnogenregmap",
       "-Xverifyopt:never", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:noop",
       "-Xincludeselectedmethod", "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:nosuchluck",
       "-Xjitoffset:none", "-Xjitconfig:yes", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile",
       "-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=1337"
   };

   // Check they are ignored when parsed one at a time
   for (auto&& arg : ignored_args) {
     SCOPED_TRACE(arg);
     EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(arg);
   }

   // Check they are ignored when we pass it all together at once
   std::vector<const char*> argv = ignored_args;
   EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv);
 }  //  TEST_F

 TEST_F(CmdlineParserTest, MultipleArguments) {
   EXPECT_TRUE(IsResultSuccessful(parser_->Parse(
       "-help -XX:ForegroundHeapGrowthMultiplier=0.5 "
       "-Xnodex2oat -Xmethod-trace -XX:LargeObjectSpace=map")));

   auto&& map = parser_->ReleaseArgumentsMap();
   EXPECT_EQ(5u, map.Size());
   EXPECT_KEY_VALUE(map, M::Help, Unit{});  // NOLINT [whitespace/braces] [5]
   EXPECT_KEY_VALUE(map, M::ForegroundHeapGrowthMultiplier, 0.5);
   EXPECT_KEY_VALUE(map, M::Dex2Oat, false);
   EXPECT_KEY_VALUE(map, M::MethodTrace, Unit{});  // NOLINT [whitespace/braces] [5]
   EXPECT_KEY_VALUE(map, M::LargeObjectSpace, gc::space::LargeObjectSpaceType::kMap);
 }  //  TEST_F
 }  // namespace art
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "cmdline_parser.h"
	#include "runtime/runtime_options.h"
	#include "runtime/parsed_options.h"

	#include "utils.h"
	#include <numeric>
	#include "gtest/gtest.h"
	#include "runtime/experimental_flags.h"

	#define EXPECT_NULL(expected) EXPECT_EQ(reinterpret_cast<const void*>(expected), \
	reinterpret_cast<void*>(nullptr));

	namespace art {
	bool UsuallyEquals(double expected, double actual);

	// This has a gtest dependency, which is why it's in the gtest only.
	bool operator==(const TestProfilerOptions& lhs, const TestProfilerOptions& rhs) {
	return lhs.enabled_ == rhs.enabled_ &&
	lhs.output_file_name_ == rhs.output_file_name_ &&
	lhs.period_s_ == rhs.period_s_ &&
	lhs.duration_s_ == rhs.duration_s_ &&
	lhs.interval_us_ == rhs.interval_us_ &&
	UsuallyEquals(lhs.backoff_coefficient_, rhs.backoff_coefficient_) &&
	UsuallyEquals(lhs.start_immediately_, rhs.start_immediately_) &&
	UsuallyEquals(lhs.top_k_threshold_, rhs.top_k_threshold_) &&
	UsuallyEquals(lhs.top_k_change_threshold_, rhs.top_k_change_threshold_) &&
	lhs.profile_type_ == rhs.profile_type_ &&
	lhs.max_stack_depth_ == rhs.max_stack_depth_;
	}

	bool UsuallyEquals(double expected, double actual) {
	using FloatingPoint = ::testing::internal::FloatingPoint<double>;

	FloatingPoint exp(expected);
	FloatingPoint act(actual);

	// Compare with ULPs instead of comparing with ==
	return exp.AlmostEquals(act);
	}

	template <typename T>
	bool UsuallyEquals(const T& expected, const T& actual,
	typename std::enable_if<
	detail::SupportsEqualityOperator<T>::value>::type* = 0) {
	return expected == actual;
	}

	// Try to use memcmp to compare simple plain-old-data structs.
	//
	// This should not generate false positives, but it can generate false negatives.
	// This will mostly work except for fields like float which can have different bit patterns
	// that are nevertheless equal.
	// If a test is failing because the structs aren't "equal" when they really are
	// then it's recommended to implement operator== for it instead.
	template <typename T, typename ... Ignore>
	bool UsuallyEquals(const T& expected, const T& actual,
	const Ignore& ... more ATTRIBUTE_UNUSED,
	typename std::enable_if<std::is_pod<T>::value>::type* = 0,
	typename std::enable_if<!detail::SupportsEqualityOperator<T>::value>::type* = 0
	) {
	return memcmp(std::addressof(expected), std::addressof(actual), sizeof(T)) == 0;
	}

	bool UsuallyEquals(const XGcOption& expected, const XGcOption& actual) {
	return memcmp(std::addressof(expected), std::addressof(actual), sizeof(expected)) == 0;
	}

	bool UsuallyEquals(const char* expected, std::string actual) {
	return std::string(expected) == actual;
	}

	template <typename TMap, typename TKey, typename T>
	::testing::AssertionResult IsExpectedKeyValue(const T& expected,
	const TMap& map,
	const TKey& key) {
	auto* actual = map.Get(key);
	if (actual != nullptr) {
	if (!UsuallyEquals(expected, *actual)) {
	return ::testing::AssertionFailure()
	<< "expected " << detail::ToStringAny(expected) << " but got "
	<< detail::ToStringAny(*actual);
	}
	return ::testing::AssertionSuccess();
	}

	return ::testing::AssertionFailure() << "key was not in the map";
	}

	template <typename TMap, typename TKey, typename T>
	::testing::AssertionResult IsExpectedDefaultKeyValue(const T& expected,
	const TMap& map,
	const TKey& key) {
	const T& actual = map.GetOrDefault(key);
	if (!UsuallyEquals(expected, actual)) {
	return ::testing::AssertionFailure()
	<< "expected " << detail::ToStringAny(expected) << " but got "
	<< detail::ToStringAny(actual);
	}
	return ::testing::AssertionSuccess();
	}

	class CmdlineParserTest : public ::testing::Test {
	public:
	CmdlineParserTest() = default;
	~CmdlineParserTest() = default;

	protected:
	using M = RuntimeArgumentMap;
	using RuntimeParser = ParsedOptions::RuntimeParser;

	static void SetUpTestCase() {
	art::InitLogging(nullptr); // argv = null
	}

	virtual void SetUp() {
	parser_ = ParsedOptions::MakeParser(false); // do not ignore unrecognized options
	}

	static ::testing::AssertionResult IsResultSuccessful(CmdlineResult result) {
	if (result.IsSuccess()) {
	return ::testing::AssertionSuccess();
	} else {
	return ::testing::AssertionFailure()
	<< result.GetStatus() << " with: " << result.GetMessage();
	}
	}

	static ::testing::AssertionResult IsResultFailure(CmdlineResult result,
	CmdlineResult::Status failure_status) {
	if (result.IsSuccess()) {
	return ::testing::AssertionFailure() << " got success but expected failure: "
	<< failure_status;
	} else if (result.GetStatus() == failure_status) {
	return ::testing::AssertionSuccess();
	}

	return ::testing::AssertionFailure() << " expected failure " << failure_status
	<< " but got " << result.GetStatus();
	}

	std::unique_ptr<RuntimeParser> parser_;
	};

	#define EXPECT_KEY_EXISTS(map, key) EXPECT_TRUE((map).Exists(key))
	#define EXPECT_KEY_VALUE(map, key, expected) EXPECT_TRUE(IsExpectedKeyValue(expected, map, key))
	#define EXPECT_DEFAULT_KEY_VALUE(map, key, expected) EXPECT_TRUE(IsExpectedDefaultKeyValue(expected, map, key))

	#define _EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv) \
	do { \
	EXPECT_TRUE(IsResultSuccessful(parser_->Parse(argv))); \
	EXPECT_EQ(0u, parser_->GetArgumentsMap().Size()); \

	#define EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv) \
	_EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv); \
	} while (false)

	#define EXPECT_SINGLE_PARSE_DEFAULT_VALUE(expected, argv, key)\
	_EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv); \
	RuntimeArgumentMap args = parser_->ReleaseArgumentsMap(); \
	EXPECT_DEFAULT_KEY_VALUE(args, key, expected); \
	} while (false) // NOLINT [readability/namespace] [5]

	#define _EXPECT_SINGLE_PARSE_EXISTS(argv, key) \
	do { \
	EXPECT_TRUE(IsResultSuccessful(parser_->Parse(argv))); \
	RuntimeArgumentMap args = parser_->ReleaseArgumentsMap(); \
	EXPECT_EQ(1u, args.Size()); \
	EXPECT_KEY_EXISTS(args, key); \

	#define EXPECT_SINGLE_PARSE_EXISTS(argv, key) \
	_EXPECT_SINGLE_PARSE_EXISTS(argv, key); \
	} while (false)

	#define EXPECT_SINGLE_PARSE_VALUE(expected, argv, key) \
	_EXPECT_SINGLE_PARSE_EXISTS(argv, key); \
	EXPECT_KEY_VALUE(args, key, expected); \
	} while (false) // NOLINT [readability/namespace] [5]

	#define EXPECT_SINGLE_PARSE_VALUE_STR(expected, argv, key) \
	EXPECT_SINGLE_PARSE_VALUE(std::string(expected), argv, key)

	#define EXPECT_SINGLE_PARSE_FAIL(argv, failure_status) \
	do { \
	EXPECT_TRUE(IsResultFailure(parser_->Parse(argv), failure_status));\
	RuntimeArgumentMap args = parser_->ReleaseArgumentsMap();\
	EXPECT_EQ(0u, args.Size()); \
	} while (false)

	TEST_F(CmdlineParserTest, TestSimpleSuccesses) {
	auto& parser = *parser_;

	EXPECT_LT(0u, parser.CountDefinedArguments());

	{
	// Test case 1: No command line arguments
	EXPECT_TRUE(IsResultSuccessful(parser.Parse("")));
	RuntimeArgumentMap args = parser.ReleaseArgumentsMap();
	EXPECT_EQ(0u, args.Size());
	}

	EXPECT_SINGLE_PARSE_EXISTS("-Xzygote", M::Zygote);
	EXPECT_SINGLE_PARSE_VALUE_STR("/hello/world", "-Xbootclasspath:/hello/world", M::BootClassPath);
	EXPECT_SINGLE_PARSE_VALUE("/hello/world", "-Xbootclasspath:/hello/world", M::BootClassPath);
	EXPECT_SINGLE_PARSE_VALUE(Memory<1>(234), "-Xss234", M::StackSize);
	EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(1234*MB), "-Xms1234m", M::MemoryInitialSize);
	EXPECT_SINGLE_PARSE_VALUE(true, "-XX:EnableHSpaceCompactForOOM", M::EnableHSpaceCompactForOOM);
	EXPECT_SINGLE_PARSE_VALUE(false, "-XX:DisableHSpaceCompactForOOM", M::EnableHSpaceCompactForOOM);
	EXPECT_SINGLE_PARSE_VALUE(0.5, "-XX:HeapTargetUtilization=0.5", M::HeapTargetUtilization);
	EXPECT_SINGLE_PARSE_VALUE(5u, "-XX:ParallelGCThreads=5", M::ParallelGCThreads);
	EXPECT_SINGLE_PARSE_EXISTS("-Xno-dex-file-fallback", M::NoDexFileFallback);
	} // TEST_F

	TEST_F(CmdlineParserTest, TestSimpleFailures) {
	// Test argument is unknown to the parser
	EXPECT_SINGLE_PARSE_FAIL("abcdefg^%@#*(@#", CmdlineResult::kUnknown);
	// Test value map substitution fails
	EXPECT_SINGLE_PARSE_FAIL("-Xverify:whatever", CmdlineResult::kFailure);
	// Test value type parsing failures
	EXPECT_SINGLE_PARSE_FAIL("-Xsswhatever", CmdlineResult::kFailure); // invalid memory value
	EXPECT_SINGLE_PARSE_FAIL("-Xms123", CmdlineResult::kFailure); // memory value too small
	EXPECT_SINGLE_PARSE_FAIL("-XX:HeapTargetUtilization=0.0", CmdlineResult::kOutOfRange); // toosmal
	EXPECT_SINGLE_PARSE_FAIL("-XX:HeapTargetUtilization=2.0", CmdlineResult::kOutOfRange); // toolarg
	EXPECT_SINGLE_PARSE_FAIL("-XX:ParallelGCThreads=-5", CmdlineResult::kOutOfRange); // too small
	EXPECT_SINGLE_PARSE_FAIL("-Xgc:blablabla", CmdlineResult::kUsage); // not a valid suboption
	} // TEST_F

	TEST_F(CmdlineParserTest, TestLogVerbosity) {
	{
	const char* log_args = "-verbose:"
	"class,compiler,gc,heap,jdwp,jni,monitor,profiler,signals,startup,third-party-jni,"
	"threads,verifier";

	LogVerbosity log_verbosity = LogVerbosity();
	log_verbosity.class_linker = true;
	log_verbosity.compiler = true;
	log_verbosity.gc = true;
	log_verbosity.heap = true;
	log_verbosity.jdwp = true;
	log_verbosity.jni = true;
	log_verbosity.monitor = true;
	log_verbosity.profiler = true;
	log_verbosity.signals = true;
	log_verbosity.startup = true;
	log_verbosity.third_party_jni = true;
	log_verbosity.threads = true;
	log_verbosity.verifier = true;

	EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
	}

	{
	const char* log_args = "-verbose:"
	"class,compiler,gc,heap,jdwp,jni,monitor";

	LogVerbosity log_verbosity = LogVerbosity();
	log_verbosity.class_linker = true;
	log_verbosity.compiler = true;
	log_verbosity.gc = true;
	log_verbosity.heap = true;
	log_verbosity.jdwp = true;
	log_verbosity.jni = true;
	log_verbosity.monitor = true;

	EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
	}

	EXPECT_SINGLE_PARSE_FAIL("-verbose:blablabla", CmdlineResult::kUsage); // invalid verbose opt

	{
	const char* log_args = "-verbose:deopt";
	LogVerbosity log_verbosity = LogVerbosity();
	log_verbosity.deopt = true;
	EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
	}

	{
	const char* log_args = "-verbose:oat";
	LogVerbosity log_verbosity = LogVerbosity();
	log_verbosity.oat = true;
	EXPECT_SINGLE_PARSE_VALUE(log_verbosity, log_args, M::Verbose);
	}
	} // TEST_F

	// TODO: Enable this b/19274810
	TEST_F(CmdlineParserTest, DISABLED_TestXGcOption) {
	/*
	* Test success
	*/
	{
	XGcOption option_all_true{}; // NOLINT [readability/braces] [4]
	option_all_true.collector_type_ = gc::CollectorType::kCollectorTypeCMS;
	option_all_true.verify_pre_gc_heap_ = true;
	option_all_true.verify_pre_sweeping_heap_ = true;
	option_all_true.verify_post_gc_heap_ = true;
	option_all_true.verify_pre_gc_rosalloc_ = true;
	option_all_true.verify_pre_sweeping_rosalloc_ = true;
	option_all_true.verify_post_gc_rosalloc_ = true;

	const char * xgc_args_all_true = "-Xgc:concurrent,"
	"preverify,presweepingverify,postverify,"
	"preverify_rosalloc,presweepingverify_rosalloc,"
	"postverify_rosalloc,precise,"
	"verifycardtable";

	EXPECT_SINGLE_PARSE_VALUE(option_all_true, xgc_args_all_true, M::GcOption);

	XGcOption option_all_false{}; // NOLINT [readability/braces] [4]
	option_all_false.collector_type_ = gc::CollectorType::kCollectorTypeMS;
	option_all_false.verify_pre_gc_heap_ = false;
	option_all_false.verify_pre_sweeping_heap_ = false;
	option_all_false.verify_post_gc_heap_ = false;
	option_all_false.verify_pre_gc_rosalloc_ = false;
	option_all_false.verify_pre_sweeping_rosalloc_ = false;
	option_all_false.verify_post_gc_rosalloc_ = false;

	const char* xgc_args_all_false = "-Xgc:nonconcurrent,"
	"nopreverify,nopresweepingverify,nopostverify,nopreverify_rosalloc,"
	"nopresweepingverify_rosalloc,nopostverify_rosalloc,noprecise,noverifycardtable";

	EXPECT_SINGLE_PARSE_VALUE(option_all_false, xgc_args_all_false, M::GcOption);

	XGcOption option_all_default{}; // NOLINT [readability/braces] [4]

	const char* xgc_args_blank = "-Xgc:";
	EXPECT_SINGLE_PARSE_VALUE(option_all_default, xgc_args_blank, M::GcOption);
	}

	/*
	* Test failures
	*/
	EXPECT_SINGLE_PARSE_FAIL("-Xgc:blablabla", CmdlineResult::kUsage); // invalid Xgc opt
	} // TEST_F

	/*
	* {"-Xrunjdwp:_", "-agentlib:jdwp=_"}
	*/
	TEST_F(CmdlineParserTest, TestJdwpOptions) {
	/*
	* Test success
	*/
	{
	/*
	* "Example: -Xrunjdwp:transport=dt_socket,address=8000,server=y\n"
	*/
	JDWP::JdwpOptions opt = JDWP::JdwpOptions();
	opt.transport = JDWP::JdwpTransportType::kJdwpTransportSocket;
	opt.port = 8000;
	opt.server = true;

	const char *opt_args = "-Xrunjdwp:transport=dt_socket,address=8000,server=y";

	EXPECT_SINGLE_PARSE_VALUE(opt, opt_args, M::JdwpOptions);
	}

	{
	/*
	* "Example: -agentlib:jdwp=transport=dt_socket,address=localhost:6500,server=n\n");
	*/
	JDWP::JdwpOptions opt = JDWP::JdwpOptions();
	opt.transport = JDWP::JdwpTransportType::kJdwpTransportSocket;
	opt.host = "localhost";
	opt.port = 6500;
	opt.server = false;

	const char *opt_args = "-agentlib:jdwp=transport=dt_socket,address=localhost:6500,server=n";

	EXPECT_SINGLE_PARSE_VALUE(opt, opt_args, M::JdwpOptions);
	}

	/*
	* Test failures
	*/
	EXPECT_SINGLE_PARSE_FAIL("-Xrunjdwp:help", CmdlineResult::kUsage); // usage for help only
	EXPECT_SINGLE_PARSE_FAIL("-Xrunjdwp:blabla", CmdlineResult::kFailure); // invalid subarg
	EXPECT_SINGLE_PARSE_FAIL("-agentlib:jdwp=help", CmdlineResult::kUsage); // usage for help only
	EXPECT_SINGLE_PARSE_FAIL("-agentlib:jdwp=blabla", CmdlineResult::kFailure); // invalid subarg
	} // TEST_F

	/*
	* -D_ -D_ -D_ ...
	*/
	TEST_F(CmdlineParserTest, TestPropertiesList) {
	/*
	* Test successes
	*/
	{
	std::vector<std::string> opt = {"hello"};

	EXPECT_SINGLE_PARSE_VALUE(opt, "-Dhello", M::PropertiesList);
	}

	{
	std::vector<std::string> opt = {"hello", "world"};

	EXPECT_SINGLE_PARSE_VALUE(opt, "-Dhello -Dworld", M::PropertiesList);
	}

	{
	std::vector<std::string> opt = {"one", "two", "three"};

	EXPECT_SINGLE_PARSE_VALUE(opt, "-Done -Dtwo -Dthree", M::PropertiesList);
	}
	} // TEST_F

	/*
	* -Xcompiler-option foo -Xcompiler-option bar ...
	*/
	TEST_F(CmdlineParserTest, TestCompilerOption) {
	/*
	* Test successes
	*/
	{
	std::vector<std::string> opt = {"hello"};
	EXPECT_SINGLE_PARSE_VALUE(opt, "-Xcompiler-option hello", M::CompilerOptions);
	}

	{
	std::vector<std::string> opt = {"hello", "world"};
	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xcompiler-option hello -Xcompiler-option world",
	M::CompilerOptions);
	}

	{
	std::vector<std::string> opt = {"one", "two", "three"};
	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xcompiler-option one -Xcompiler-option two -Xcompiler-option three",
	M::CompilerOptions);
	}
	} // TEST_F

	/*
	* -Xjit, -Xnojit, -Xjitcodecachesize, Xjitcompilethreshold
	*/
	TEST_F(CmdlineParserTest, TestJitOptions) {
	/*
	* Test successes
	*/
	{
	EXPECT_SINGLE_PARSE_VALUE(true, "-Xusejit:true", M::UseJIT);
	EXPECT_SINGLE_PARSE_VALUE(false, "-Xusejit:false", M::UseJIT);
	}
	{
	EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(16 * KB), "-Xjitcodecachesize:16K", M::JITCodeCacheCapacity);
	EXPECT_SINGLE_PARSE_VALUE(MemoryKiB(16 * MB), "-Xjitcodecachesize:16M", M::JITCodeCacheCapacity);
	}
	{
	EXPECT_SINGLE_PARSE_VALUE(12345u, "-Xjitthreshold:12345", M::JITCompileThreshold);
	}
	} // TEST_F

	/*
	* -X-profile-*
	*/
	TEST_F(CmdlineParserTest, TestProfilerOptions) {
	/*
	* Test successes
	*/

	{
	TestProfilerOptions opt;
	opt.enabled_ = true;

	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xenable-profiler",
	M::ProfilerOpts);
	}

	{
	TestProfilerOptions opt;
	// also need to test 'enabled'
	opt.output_file_name_ = "hello_world.txt";

	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xprofile-filename:hello_world.txt ",
	M::ProfilerOpts);
	}

	{
	TestProfilerOptions opt = TestProfilerOptions();
	// also need to test 'enabled'
	opt.output_file_name_ = "output.txt";
	opt.period_s_ = 123u;
	opt.duration_s_ = 456u;
	opt.interval_us_ = 789u;
	opt.backoff_coefficient_ = 2.0;
	opt.start_immediately_ = true;
	opt.top_k_threshold_ = 50.0;
	opt.top_k_change_threshold_ = 60.0;
	opt.profile_type_ = kProfilerMethod;
	opt.max_stack_depth_ = 1337u;

	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xprofile-filename:output.txt "
	"-Xprofile-period:123 "
	"-Xprofile-duration:456 "
	"-Xprofile-interval:789 "
	"-Xprofile-backoff:2.0 "
	"-Xprofile-start-immediately "
	"-Xprofile-top-k-threshold:50.0 "
	"-Xprofile-top-k-change-threshold:60.0 "
	"-Xprofile-type:method "
	"-Xprofile-max-stack-depth:1337",
	M::ProfilerOpts);
	}

	{
	TestProfilerOptions opt = TestProfilerOptions();
	opt.profile_type_ = kProfilerBoundedStack;

	EXPECT_SINGLE_PARSE_VALUE(opt,
	"-Xprofile-type:stack",
	M::ProfilerOpts);
	}
	} // TEST_F

	/* -Xexperimental:_ */
	TEST_F(CmdlineParserTest, TestExperimentalFlags) {
	// Off by default
	EXPECT_SINGLE_PARSE_DEFAULT_VALUE(ExperimentalFlags::kNone,
	"",
	M::Experimental);

	// Disabled explicitly
	EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kNone,
	"-Xexperimental:none",
	M::Experimental);

	// Enabled explicitly
	EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kLambdas,
	"-Xexperimental:lambdas",
	M::Experimental);
	// Enabled explicitly
	EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kDefaultMethods,
	"-Xexperimental:default-methods",
	M::Experimental);

	// Enabled both
	EXPECT_SINGLE_PARSE_VALUE(ExperimentalFlags::kDefaultMethods \| ExperimentalFlags::kLambdas,
	"-Xexperimental:default-methods "
	"-Xexperimental:lambdas",
	M::Experimental);
	}

	// -Xverify:_
	TEST_F(CmdlineParserTest, TestVerify) {
	EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kNone, "-Xverify:none", M::Verify);
	EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kEnable, "-Xverify:remote", M::Verify);
	EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kEnable, "-Xverify:all", M::Verify);
	EXPECT_SINGLE_PARSE_VALUE(verifier::VerifyMode::kSoftFail, "-Xverify:softfail", M::Verify);
	}

	TEST_F(CmdlineParserTest, TestIgnoreUnrecognized) {
	RuntimeParser::Builder parserBuilder;

	parserBuilder
	.Define("-help")
	.IntoKey(M::Help)
	.IgnoreUnrecognized(true);

	parser_.reset(new RuntimeParser(parserBuilder.Build()));

	EXPECT_SINGLE_PARSE_EMPTY_SUCCESS("-non-existent-option");
	EXPECT_SINGLE_PARSE_EMPTY_SUCCESS("-non-existent-option1 --non-existent-option-2");
	} // TEST_F

	TEST_F(CmdlineParserTest, TestIgnoredArguments) {
	std::initializer_list<const char*> ignored_args = {
	"-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa",
	"-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:abdef",
	"-Xdexopt:foobar", "-Xnoquithandler", "-Xjnigreflimit:ixnay", "-Xgenregmap", "-Xnogenregmap",
	"-Xverifyopt:never", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:noop",
	"-Xincludeselectedmethod", "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:nosuchluck",
	"-Xjitoffset:none", "-Xjitconfig:yes", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile",
	"-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=1337"
	};

	// Check they are ignored when parsed one at a time
	for (auto&& arg : ignored_args) {
	SCOPED_TRACE(arg);
	EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(arg);
	}

	// Check they are ignored when we pass it all together at once
	std::vector<const char*> argv = ignored_args;
	EXPECT_SINGLE_PARSE_EMPTY_SUCCESS(argv);
	} // TEST_F

	TEST_F(CmdlineParserTest, MultipleArguments) {
	EXPECT_TRUE(IsResultSuccessful(parser_->Parse(
	"-help -XX:ForegroundHeapGrowthMultiplier=0.5 "
	"-Xnodex2oat -Xmethod-trace -XX:LargeObjectSpace=map")));

	auto&& map = parser_->ReleaseArgumentsMap();
	EXPECT_EQ(5u, map.Size());
	EXPECT_KEY_VALUE(map, M::Help, Unit{}); // NOLINT [whitespace/braces] [5]
	EXPECT_KEY_VALUE(map, M::ForegroundHeapGrowthMultiplier, 0.5);
	EXPECT_KEY_VALUE(map, M::Dex2Oat, false);
	EXPECT_KEY_VALUE(map, M::MethodTrace, Unit{}); // NOLINT [whitespace/braces] [5]
	EXPECT_KEY_VALUE(map, M::LargeObjectSpace, gc::space::LargeObjectSpaceType::kMap);
	} // TEST_F
	} // namespace art