common/libs/utils/flag_parser_test.cpp - device/google/cuttlefish - Git at Google

 /*
  * Copyright (C) 2021 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 <common/libs/utils/flag_parser.h>

 #include <gtest/gtest.h>
 #include <libxml/tree.h>
 #include <map>
 #include <optional>
 #include <sstream>
 #include <string>
 #include <vector>

 namespace cuttlefish {

 TEST(FlagParser, DuplicateAlias) {
   FlagAlias alias = {FlagAliasMode::kFlagExact, "--flag"};
   ASSERT_DEATH({ Flag().Alias(alias).Alias(alias); }, "Duplicate flag alias");
 }

 TEST(FlagParser, ConflictingAlias) {
   FlagAlias exact_alias = {FlagAliasMode::kFlagExact, "--flag"};
   FlagAlias following_alias = {FlagAliasMode::kFlagConsumesFollowing, "--flag"};
   ASSERT_DEATH({ Flag().Alias(exact_alias).Alias(following_alias); },
                "Overlapping flag aliases");
 }

 TEST(FlagParser, StringFlag) {
   std::string value;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_TRUE(flag.Parse({"-myflag=a"}));
   ASSERT_EQ(value, "a");
   ASSERT_TRUE(flag.Parse({"--myflag=b"}));
   ASSERT_EQ(value, "b");
   ASSERT_TRUE(flag.Parse({"-myflag", "c"}));
   ASSERT_EQ(value, "c");
   ASSERT_TRUE(flag.Parse({"--myflag", "d"}));
   ASSERT_EQ(value, "d");
   ASSERT_TRUE(flag.Parse({"--myflag="}));
   ASSERT_EQ(value, "");
 }

 std::optional<std::map<std::string, std::string>> flagXml(const Flag& f) {
   std::stringstream xml_stream;
   if (!f.WriteGflagsCompatXml(xml_stream)) {
     return {};
   }
   auto xml = xml_stream.str();
   // Holds all memory for the parsed structure.
   std::unique_ptr<xmlDoc, xmlFreeFunc> doc(
       xmlReadMemory(xml.c_str(), xml.size(), nullptr, nullptr, 0), xmlFree);
   if (!doc) {
     return {};
   }
   xmlNodePtr root_element = xmlDocGetRootElement(doc.get());
   std::map<std::string, std::string> elements_map;
   for (auto elem = root_element->children; elem != nullptr; elem = elem->next) {
     if (elem->type != xmlElementType::XML_ELEMENT_NODE) {
       continue;
     }
     elements_map[(char*)elem->name] = "";
     if (elem->children == nullptr) {
       continue;
     }
     if (elem->children->type != XML_TEXT_NODE) {
       continue;
     }
     elements_map[(char*)elem->name] = (char*)elem->children->content;
   }
   return elements_map;
 }

 TEST(FlagParser, GflagsIncompatibleFlag) {
   auto flag = Flag().Alias({FlagAliasMode::kFlagExact, "--flag"});
   ASSERT_FALSE(flagXml(flag));
 }

 TEST(FlagParser, StringFlagXml) {
   std::string value = "somedefault";
   auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
   auto xml = flagXml(flag);
   ASSERT_TRUE(xml);
   ASSERT_NE((*xml)["file"], "");
   ASSERT_EQ((*xml)["name"], "myflag");
   ASSERT_EQ((*xml)["meaning"], "somehelp");
   ASSERT_EQ((*xml)["default"], "somedefault");
   ASSERT_EQ((*xml)["current"], "somedefault");
   ASSERT_EQ((*xml)["type"], "string");
 }

 TEST(FlagParser, RepeatedStringFlag) {
   std::string value;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_TRUE(flag.Parse({"-myflag=a", "--myflag", "b"}));
   ASSERT_EQ(value, "b");
 }

 TEST(FlagParser, RepeatedListFlag) {
   std::vector<std::string> elems;
   auto flag = GflagsCompatFlag("myflag");
   flag.Setter([&elems](const FlagMatch& match) {
     elems.push_back(match.value);
     return true;
   });
   ASSERT_TRUE(flag.Parse({"-myflag=a", "--myflag", "b"}));
   ASSERT_EQ(elems, (std::vector<std::string>{"a", "b"}));
 }

 TEST(FlagParser, FlagRemoval) {
   std::string value;
   auto flag = GflagsCompatFlag("myflag", value);
   std::vector<std::string> flags = {"-myflag=a", "-otherflag=c"};
   ASSERT_TRUE(flag.Parse(flags));
   ASSERT_EQ(value, "a");
   ASSERT_EQ(flags, std::vector<std::string>{"-otherflag=c"});
   flags = {"-otherflag=a", "-myflag=c"};
   ASSERT_TRUE(flag.Parse(flags));
   ASSERT_EQ(value, "c");
   ASSERT_EQ(flags, std::vector<std::string>{"-otherflag=a"});
 }

 TEST(FlagParser, IntFlag) {
   std::int32_t value = 0;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_TRUE(flag.Parse({"-myflag=5"}));
   ASSERT_EQ(value, 5);
   ASSERT_TRUE(flag.Parse({"--myflag=6"}));
   ASSERT_EQ(value, 6);
   ASSERT_TRUE(flag.Parse({"-myflag", "7"}));
   ASSERT_EQ(value, 7);
   ASSERT_TRUE(flag.Parse({"--myflag", "8"}));
   ASSERT_EQ(value, 8);
 }

 TEST(FlagParser, IntFlagXml) {
   int value = 5;
   auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
   auto xml = flagXml(flag);
   ASSERT_TRUE(xml);
   ASSERT_NE((*xml)["file"], "");
   ASSERT_EQ((*xml)["name"], "myflag");
   ASSERT_EQ((*xml)["meaning"], "somehelp");
   ASSERT_EQ((*xml)["default"], "5");
   ASSERT_EQ((*xml)["current"], "5");
   ASSERT_EQ((*xml)["type"], "string");
 }

 TEST(FlagParser, BoolFlag) {
   bool value = false;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_TRUE(flag.Parse({"-myflag"}));
   ASSERT_TRUE(value);

   value = false;
   ASSERT_TRUE(flag.Parse({"--myflag"}));
   ASSERT_TRUE(value);

   value = false;
   ASSERT_TRUE(flag.Parse({"-myflag=true"}));
   ASSERT_TRUE(value);

   value = false;
   ASSERT_TRUE(flag.Parse({"--myflag=true"}));
   ASSERT_TRUE(value);

   value = true;
   ASSERT_TRUE(flag.Parse({"-nomyflag"}));
   ASSERT_FALSE(value);

   value = true;
   ASSERT_TRUE(flag.Parse({"--nomyflag"}));
   ASSERT_FALSE(value);

   value = true;
   ASSERT_TRUE(flag.Parse({"-myflag=false"}));
   ASSERT_FALSE(value);

   value = true;
   ASSERT_TRUE(flag.Parse({"--myflag=false"}));
   ASSERT_FALSE(value);

   ASSERT_FALSE(flag.Parse({"--myflag=nonsense"}));
 }

 TEST(FlagParser, BoolFlagXml) {
   bool value = true;
   auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
   auto xml = flagXml(flag);
   ASSERT_TRUE(xml);
   ASSERT_NE((*xml)["file"], "");
   ASSERT_EQ((*xml)["name"], "myflag");
   ASSERT_EQ((*xml)["meaning"], "somehelp");
   ASSERT_EQ((*xml)["default"], "true");
   ASSERT_EQ((*xml)["current"], "true");
   ASSERT_EQ((*xml)["type"], "bool");
 }

 TEST(FlagParser, StringIntFlag) {
   std::int32_t int_value = 0;
   std::string string_value;
   auto int_flag = GflagsCompatFlag("int", int_value);
   auto string_flag = GflagsCompatFlag("string", string_value);
   std::vector<Flag> flags = {int_flag, string_flag};
   ASSERT_TRUE(ParseFlags(flags, {"-int=5", "-string=a"}));
   ASSERT_EQ(int_value, 5);
   ASSERT_EQ(string_value, "a");
   ASSERT_TRUE(ParseFlags(flags, {"--int=6", "--string=b"}));
   ASSERT_EQ(int_value, 6);
   ASSERT_EQ(string_value, "b");
   ASSERT_TRUE(ParseFlags(flags, {"-int", "7", "-string", "c"}));
   ASSERT_EQ(int_value, 7);
   ASSERT_EQ(string_value, "c");
   ASSERT_TRUE(ParseFlags(flags, {"--int", "8", "--string", "d"}));
   ASSERT_EQ(int_value, 8);
   ASSERT_EQ(string_value, "d");
 }

 TEST(FlagParser, InvalidStringFlag) {
   std::string value;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_FALSE(flag.Parse({"-myflag"}));
   ASSERT_FALSE(flag.Parse({"--myflag"}));
 }

 TEST(FlagParser, InvalidIntFlag) {
   int value;
   auto flag = GflagsCompatFlag("myflag", value);
   ASSERT_FALSE(flag.Parse({"-myflag"}));
   ASSERT_FALSE(flag.Parse({"--myflag"}));
   ASSERT_FALSE(flag.Parse({"-myflag=abc"}));
   ASSERT_FALSE(flag.Parse({"--myflag=def"}));
   ASSERT_FALSE(flag.Parse({"-myflag", "abc"}));
   ASSERT_FALSE(flag.Parse({"--myflag", "def"}));
 }

 TEST(FlagParser, InvalidFlagGuard) {
   auto flag = InvalidFlagGuard();
   ASSERT_TRUE(flag.Parse({}));
   ASSERT_TRUE(flag.Parse({"positional"}));
   ASSERT_TRUE(flag.Parse({"positional", "positional2"}));
   ASSERT_FALSE(flag.Parse({"-flag"}));
   ASSERT_FALSE(flag.Parse({"-"}));
 }

 TEST(FlagParser, UnexpectedArgumentGuard) {
   auto flag = UnexpectedArgumentGuard();
   ASSERT_TRUE(flag.Parse({}));
   ASSERT_FALSE(flag.Parse({"positional"}));
   ASSERT_FALSE(flag.Parse({"positional", "positional2"}));
   ASSERT_FALSE(flag.Parse({"-flag"}));
   ASSERT_FALSE(flag.Parse({"-"}));
 }

 class FlagConsumesArbitraryTest : public ::testing::Test {
  protected:
   void SetUp() override {
     elems_.clear();
     flag_ = Flag()
                 .Alias({FlagAliasMode::kFlagConsumesArbitrary, "--flag"})
                 .Setter([this](const FlagMatch& match) {
                   elems_.push_back(match.value);
                   return true;
                 });
   }
   Flag flag_;
   std::vector<std::string> elems_;
 };

 TEST_F(FlagConsumesArbitraryTest, NoValues) {
   std::vector<std::string> inputs = {"--flag"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{}));
   ASSERT_EQ(elems_, (std::vector<std::string>{""}));
 }

 TEST_F(FlagConsumesArbitraryTest, OneValue) {
   std::vector<std::string> inputs = {"--flag", "value"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{}));
   ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
 }

 TEST_F(FlagConsumesArbitraryTest, TwoValues) {
   std::vector<std::string> inputs = {"--flag", "value1", "value2"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{}));
   ASSERT_EQ(elems_, (std::vector<std::string>{"value1", "value2", ""}));
 }

 TEST_F(FlagConsumesArbitraryTest, NoValuesOtherFlag) {
   std::vector<std::string> inputs = {"--flag", "--otherflag"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
   ASSERT_EQ(elems_, (std::vector<std::string>{""}));
 }

 TEST_F(FlagConsumesArbitraryTest, OneValueOtherFlag) {
   std::vector<std::string> inputs = {"--flag", "value", "--otherflag"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
   ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
 }

 TEST_F(FlagConsumesArbitraryTest, TwoValuesOtherFlag) {
   std::vector<std::string> inputs = {"--flag", "v1", "v2", "--otherflag"};
   ASSERT_TRUE(flag_.Parse(inputs));
   ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
   ASSERT_EQ(elems_, (std::vector<std::string>{"v1", "v2", ""}));
 }

 }  // namespace cuttlefish
	/*
	* Copyright (C) 2021 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 <common/libs/utils/flag_parser.h>

	#include <gtest/gtest.h>
	#include <libxml/tree.h>
	#include <map>
	#include <optional>
	#include <sstream>
	#include <string>
	#include <vector>

	namespace cuttlefish {

	TEST(FlagParser, DuplicateAlias) {
	FlagAlias alias = {FlagAliasMode::kFlagExact, "--flag"};
	ASSERT_DEATH({ Flag().Alias(alias).Alias(alias); }, "Duplicate flag alias");
	}

	TEST(FlagParser, ConflictingAlias) {
	FlagAlias exact_alias = {FlagAliasMode::kFlagExact, "--flag"};
	FlagAlias following_alias = {FlagAliasMode::kFlagConsumesFollowing, "--flag"};
	ASSERT_DEATH({ Flag().Alias(exact_alias).Alias(following_alias); },
	"Overlapping flag aliases");
	}

	TEST(FlagParser, StringFlag) {
	std::string value;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_TRUE(flag.Parse({"-myflag=a"}));
	ASSERT_EQ(value, "a");
	ASSERT_TRUE(flag.Parse({"--myflag=b"}));
	ASSERT_EQ(value, "b");
	ASSERT_TRUE(flag.Parse({"-myflag", "c"}));
	ASSERT_EQ(value, "c");
	ASSERT_TRUE(flag.Parse({"--myflag", "d"}));
	ASSERT_EQ(value, "d");
	ASSERT_TRUE(flag.Parse({"--myflag="}));
	ASSERT_EQ(value, "");
	}

	std::optional<std::map<std::string, std::string>> flagXml(const Flag& f) {
	std::stringstream xml_stream;
	if (!f.WriteGflagsCompatXml(xml_stream)) {
	return {};
	}
	auto xml = xml_stream.str();
	// Holds all memory for the parsed structure.
	std::unique_ptr<xmlDoc, xmlFreeFunc> doc(
	xmlReadMemory(xml.c_str(), xml.size(), nullptr, nullptr, 0), xmlFree);
	if (!doc) {
	return {};
	}
	xmlNodePtr root_element = xmlDocGetRootElement(doc.get());
	std::map<std::string, std::string> elements_map;
	for (auto elem = root_element->children; elem != nullptr; elem = elem->next) {
	if (elem->type != xmlElementType::XML_ELEMENT_NODE) {
	continue;
	}
	elements_map[(char*)elem->name] = "";
	if (elem->children == nullptr) {
	continue;
	}
	if (elem->children->type != XML_TEXT_NODE) {
	continue;
	}
	elements_map[(char)elem->name] = (char)elem->children->content;
	}
	return elements_map;
	}

	TEST(FlagParser, GflagsIncompatibleFlag) {
	auto flag = Flag().Alias({FlagAliasMode::kFlagExact, "--flag"});
	ASSERT_FALSE(flagXml(flag));
	}

	TEST(FlagParser, StringFlagXml) {
	std::string value = "somedefault";
	auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
	auto xml = flagXml(flag);
	ASSERT_TRUE(xml);
	ASSERT_NE((*xml)["file"], "");
	ASSERT_EQ((*xml)["name"], "myflag");
	ASSERT_EQ((*xml)["meaning"], "somehelp");
	ASSERT_EQ((*xml)["default"], "somedefault");
	ASSERT_EQ((*xml)["current"], "somedefault");
	ASSERT_EQ((*xml)["type"], "string");
	}

	TEST(FlagParser, RepeatedStringFlag) {
	std::string value;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_TRUE(flag.Parse({"-myflag=a", "--myflag", "b"}));
	ASSERT_EQ(value, "b");
	}

	TEST(FlagParser, RepeatedListFlag) {
	std::vector<std::string> elems;
	auto flag = GflagsCompatFlag("myflag");
	flag.Setter([&elems](const FlagMatch& match) {
	elems.push_back(match.value);
	return true;
	});
	ASSERT_TRUE(flag.Parse({"-myflag=a", "--myflag", "b"}));
	ASSERT_EQ(elems, (std::vector<std::string>{"a", "b"}));
	}

	TEST(FlagParser, FlagRemoval) {
	std::string value;
	auto flag = GflagsCompatFlag("myflag", value);
	std::vector<std::string> flags = {"-myflag=a", "-otherflag=c"};
	ASSERT_TRUE(flag.Parse(flags));
	ASSERT_EQ(value, "a");
	ASSERT_EQ(flags, std::vector<std::string>{"-otherflag=c"});
	flags = {"-otherflag=a", "-myflag=c"};
	ASSERT_TRUE(flag.Parse(flags));
	ASSERT_EQ(value, "c");
	ASSERT_EQ(flags, std::vector<std::string>{"-otherflag=a"});
	}

	TEST(FlagParser, IntFlag) {
	std::int32_t value = 0;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_TRUE(flag.Parse({"-myflag=5"}));
	ASSERT_EQ(value, 5);
	ASSERT_TRUE(flag.Parse({"--myflag=6"}));
	ASSERT_EQ(value, 6);
	ASSERT_TRUE(flag.Parse({"-myflag", "7"}));
	ASSERT_EQ(value, 7);
	ASSERT_TRUE(flag.Parse({"--myflag", "8"}));
	ASSERT_EQ(value, 8);
	}

	TEST(FlagParser, IntFlagXml) {
	int value = 5;
	auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
	auto xml = flagXml(flag);
	ASSERT_TRUE(xml);
	ASSERT_NE((*xml)["file"], "");
	ASSERT_EQ((*xml)["name"], "myflag");
	ASSERT_EQ((*xml)["meaning"], "somehelp");
	ASSERT_EQ((*xml)["default"], "5");
	ASSERT_EQ((*xml)["current"], "5");
	ASSERT_EQ((*xml)["type"], "string");
	}

	TEST(FlagParser, BoolFlag) {
	bool value = false;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_TRUE(flag.Parse({"-myflag"}));
	ASSERT_TRUE(value);

	value = false;
	ASSERT_TRUE(flag.Parse({"--myflag"}));
	ASSERT_TRUE(value);

	value = false;
	ASSERT_TRUE(flag.Parse({"-myflag=true"}));
	ASSERT_TRUE(value);

	value = false;
	ASSERT_TRUE(flag.Parse({"--myflag=true"}));
	ASSERT_TRUE(value);

	value = true;
	ASSERT_TRUE(flag.Parse({"-nomyflag"}));
	ASSERT_FALSE(value);

	value = true;
	ASSERT_TRUE(flag.Parse({"--nomyflag"}));
	ASSERT_FALSE(value);

	value = true;
	ASSERT_TRUE(flag.Parse({"-myflag=false"}));
	ASSERT_FALSE(value);

	value = true;
	ASSERT_TRUE(flag.Parse({"--myflag=false"}));
	ASSERT_FALSE(value);

	ASSERT_FALSE(flag.Parse({"--myflag=nonsense"}));
	}

	TEST(FlagParser, BoolFlagXml) {
	bool value = true;
	auto flag = GflagsCompatFlag("myflag", value).Help("somehelp");
	auto xml = flagXml(flag);
	ASSERT_TRUE(xml);
	ASSERT_NE((*xml)["file"], "");
	ASSERT_EQ((*xml)["name"], "myflag");
	ASSERT_EQ((*xml)["meaning"], "somehelp");
	ASSERT_EQ((*xml)["default"], "true");
	ASSERT_EQ((*xml)["current"], "true");
	ASSERT_EQ((*xml)["type"], "bool");
	}

	TEST(FlagParser, StringIntFlag) {
	std::int32_t int_value = 0;
	std::string string_value;
	auto int_flag = GflagsCompatFlag("int", int_value);
	auto string_flag = GflagsCompatFlag("string", string_value);
	std::vector<Flag> flags = {int_flag, string_flag};
	ASSERT_TRUE(ParseFlags(flags, {"-int=5", "-string=a"}));
	ASSERT_EQ(int_value, 5);
	ASSERT_EQ(string_value, "a");
	ASSERT_TRUE(ParseFlags(flags, {"--int=6", "--string=b"}));
	ASSERT_EQ(int_value, 6);
	ASSERT_EQ(string_value, "b");
	ASSERT_TRUE(ParseFlags(flags, {"-int", "7", "-string", "c"}));
	ASSERT_EQ(int_value, 7);
	ASSERT_EQ(string_value, "c");
	ASSERT_TRUE(ParseFlags(flags, {"--int", "8", "--string", "d"}));
	ASSERT_EQ(int_value, 8);
	ASSERT_EQ(string_value, "d");
	}

	TEST(FlagParser, InvalidStringFlag) {
	std::string value;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_FALSE(flag.Parse({"-myflag"}));
	ASSERT_FALSE(flag.Parse({"--myflag"}));
	}

	TEST(FlagParser, InvalidIntFlag) {
	int value;
	auto flag = GflagsCompatFlag("myflag", value);
	ASSERT_FALSE(flag.Parse({"-myflag"}));
	ASSERT_FALSE(flag.Parse({"--myflag"}));
	ASSERT_FALSE(flag.Parse({"-myflag=abc"}));
	ASSERT_FALSE(flag.Parse({"--myflag=def"}));
	ASSERT_FALSE(flag.Parse({"-myflag", "abc"}));
	ASSERT_FALSE(flag.Parse({"--myflag", "def"}));
	}

	TEST(FlagParser, InvalidFlagGuard) {
	auto flag = InvalidFlagGuard();
	ASSERT_TRUE(flag.Parse({}));
	ASSERT_TRUE(flag.Parse({"positional"}));
	ASSERT_TRUE(flag.Parse({"positional", "positional2"}));
	ASSERT_FALSE(flag.Parse({"-flag"}));
	ASSERT_FALSE(flag.Parse({"-"}));
	}

	TEST(FlagParser, UnexpectedArgumentGuard) {
	auto flag = UnexpectedArgumentGuard();
	ASSERT_TRUE(flag.Parse({}));
	ASSERT_FALSE(flag.Parse({"positional"}));
	ASSERT_FALSE(flag.Parse({"positional", "positional2"}));
	ASSERT_FALSE(flag.Parse({"-flag"}));
	ASSERT_FALSE(flag.Parse({"-"}));
	}

	class FlagConsumesArbitraryTest : public ::testing::Test {
	protected:
	void SetUp() override {
	elems_.clear();
	flag_ = Flag()
	.Alias({FlagAliasMode::kFlagConsumesArbitrary, "--flag"})
	.Setter([this](const FlagMatch& match) {
	elems_.push_back(match.value);
	return true;
	});
	}
	Flag flag_;
	std::vector<std::string> elems_;
	};

	TEST_F(FlagConsumesArbitraryTest, NoValues) {
	std::vector<std::string> inputs = {"--flag"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{}));
	ASSERT_EQ(elems_, (std::vector<std::string>{""}));
	}

	TEST_F(FlagConsumesArbitraryTest, OneValue) {
	std::vector<std::string> inputs = {"--flag", "value"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{}));
	ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
	}

	TEST_F(FlagConsumesArbitraryTest, TwoValues) {
	std::vector<std::string> inputs = {"--flag", "value1", "value2"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{}));
	ASSERT_EQ(elems_, (std::vector<std::string>{"value1", "value2", ""}));
	}

	TEST_F(FlagConsumesArbitraryTest, NoValuesOtherFlag) {
	std::vector<std::string> inputs = {"--flag", "--otherflag"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
	ASSERT_EQ(elems_, (std::vector<std::string>{""}));
	}

	TEST_F(FlagConsumesArbitraryTest, OneValueOtherFlag) {
	std::vector<std::string> inputs = {"--flag", "value", "--otherflag"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
	ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
	}

	TEST_F(FlagConsumesArbitraryTest, TwoValuesOtherFlag) {
	std::vector<std::string> inputs = {"--flag", "v1", "v2", "--otherflag"};
	ASSERT_TRUE(flag_.Parse(inputs));
	ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
	ASSERT_EQ(elems_, (std::vector<std::string>{"v1", "v2", ""}));
	}

	} // namespace cuttlefish