/*
 * main.cpp -- main test file for OptionParser
 *
 * Copyright (c) 2013, 2014 David Demelier <markand@malikania.fr>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <gtest/gtest.h>

#include <OptionParser.h>

/* --------------------------------------------------------
 * Short options
 * -------------------------------------------------------- */

TEST(Short, simpleNoArg)
{
	OptionParser parser{
		{ "a", "",	Option::NoArg	},
		{ "b", "",	Option::NoArg	}
	};

	OptionPack pack = parser.parse({ "-a", "-b" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(2, static_cast<int>(pack.size()));
	ASSERT_EQ(2, pack.parsed());

	ASSERT_TRUE(pack[0] == "a");
	ASSERT_TRUE(pack[1] == "b");
}

TEST(Short, simpleArg)
{
	OptionParser parser{
		{ "v", "",	Option::NoArg	},
		{ "c", "",			}
	};

	OptionPack pack = parser.parse({ "-v", "-cfoo.conf" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(2, static_cast<int>(pack.size()));
	ASSERT_EQ(2, pack.parsed());

	ASSERT_TRUE(pack[0] == "v");
	ASSERT_TRUE(pack[1] == "c");
	ASSERT_EQ("foo.conf", pack[1].value());
}

TEST(Short, spacedArg)
{
	OptionParser parser{
		{ "v", "",	Option::NoArg	},
		{ "c", "",			}
	};

	OptionPack pack = parser.parse({ "-v", "-c", "foo.conf" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(2, static_cast<int>(pack.size()));
	ASSERT_EQ(3, pack.parsed());

	ASSERT_TRUE(pack[0] == "v");
	ASSERT_TRUE(pack[1] == "c");
	ASSERT_EQ("foo.conf", pack[1].value());
}

TEST(Short, compacted)
{
	OptionParser parser{
		{ "a", "",	Option::NoArg	},
		{ "b", "",	Option::NoArg	},
		{ "c", "",	Option::NoArg	},
	};

	OptionPack pack = parser.parse({ "-abc" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(3, static_cast<int>(pack.size()));
	ASSERT_EQ(1, pack.parsed());

	ASSERT_TRUE(pack[0] == "a");
	ASSERT_TRUE(pack[1] == "b");
	ASSERT_TRUE(pack[2] == "c");
}

TEST(Short, compactedArg)
{
	OptionParser parser{
		{ "a", "",			},
		{ "b", "",			},
		{ "c", "",			},
	};

	OptionPack pack = parser.parse({ "-abc" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(1, static_cast<int>(pack.size()));
	ASSERT_EQ(1, pack.parsed());

	ASSERT_TRUE(pack[0] == "a");
}

/* --------------------------------------------------------
 * Long options
 * -------------------------------------------------------- */

TEST(Long, simple)
{
	OptionParser parser{
		{ "",	"verbose",	Option::NoArg	},
		{ "",	"fullscreen",	Option::NoArg	}
	};

	OptionPack pack = parser.parse({ "--fullscreen" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(1, static_cast<int>(pack.size()));
	ASSERT_EQ(1, pack.parsed());

	ASSERT_TRUE(pack[0] == "fullscreen");
}

TEST(Long, simpleArg)
{
	OptionParser parser{
		{ "", "config",			},
		{ "", "level",			}
	};

	OptionPack pack = parser.parse({ "--config", "config.conf", "--level", "2" });

	ASSERT_TRUE(pack);

	ASSERT_EQ(2, static_cast<int>(pack.size()));
	ASSERT_EQ(4, pack.parsed());

	ASSERT_TRUE(pack[0] == "config");
	ASSERT_EQ("config.conf", pack[0].value());
	ASSERT_TRUE(pack[1] == "level");
	ASSERT_EQ("2", pack[1].value());
}

/* --------------------------------------------------------
 * Combined
 * -------------------------------------------------------- */

TEST(Combined, simple)
{
	OptionParser parser{
		{ "v", "verbose",	Option::NoArg	},
		{ "l", "level",		Option::NoArg	}
	};

	OptionPack pack = parser.parse({ "-v", "-l", "--verbose", "--level" });

	ASSERT_TRUE(pack);

	ASSERT_TRUE(pack[0] == "v" && pack[0] == "verbose");
	ASSERT_TRUE(pack[1] == "l" && pack[1] == "level");
	ASSERT_TRUE(pack[2] == "v" && pack[2] == "verbose");
	ASSERT_TRUE(pack[3] == "l" && pack[3] == "level");
}

/* --------------------------------------------------------
 * Flags
 * -------------------------------------------------------- */

TEST(Flags, standard)
{
	// No flags, parse unless there is an argument which is not an option
	OptionParser parser{
		{ "v", "",		Option::NoArg	}
	};

	OptionPack pack = parser.parse({ "-v", "install", "malikania" });

	ASSERT_FALSE(pack);

	ASSERT_EQ(1, static_cast<int>(pack.size()));
	ASSERT_EQ(1, pack.parsed());

	ASSERT_TRUE(pack[0] == "v");
}

TEST(Flags, unstrict)
{
	// No flags, parse unless there is an argument which is not an option
	OptionParser parser{
		{ "v", "",		Option::NoArg	},
		{ "d", "",				}
	};

	OptionPack pack = parser.parse({ "-v", "install", "malikania", "-d", "/usr/local" }, OptionParser::Unstrict);

	ASSERT_TRUE(pack);

	ASSERT_EQ(2, static_cast<int>(pack.size()));
	ASSERT_EQ(5, pack.parsed());

	ASSERT_TRUE(pack[0] == "v");
	ASSERT_TRUE(pack[1] == "d");
	ASSERT_EQ("/usr/local", pack[1].value());
}

int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);

	return RUN_ALL_TESTS();
}