Write the first batch of tests.

test/options_test.cpp

@@ -8,3 +8,111 @@
 #include "program_args/arguments.h"
 
 #include "xcode_gtest_helper.h"
+
+using testing::Eq;
+
+template <typename T, size_t N> T parse(char const * const (&argv)[N]) {
+  return T(N, argv);
+}
+
+struct LongOptionTest : program::Arguments<LongOptionTest> {
+  using program::Arguments<LongOptionTest>::Arguments;
+
+  std::string endpoint = option("endpoint");
+  int port = option("port");
+};
+
+TEST(LongOptionTest, ArgumentsAreDefaultedNaturally) {
+  auto const options = parse<LongOptionTest>({""});
+  EXPECT_THAT(options.endpoint, Eq(""));
+  EXPECT_THAT(options.port, Eq(0));
+}
+
+TEST(LongOptionTest, CanProvideStringArgument) {
+  auto const options = parse<LongOptionTest>({"", "--endpoint", "/null"});
+  EXPECT_THAT(options.endpoint, Eq("/null"));
+}
+
+TEST(LongOptionTest, CanProvideNumericArgument) {
+  auto const options = parse<LongOptionTest>({"", "--port", "443"});
+  EXPECT_THAT(options.port, Eq(443));
+}
+
+TEST(LongOptionTest, WillThrowOnInvalidNumericArgument) {
+  EXPECT_THROW(parse<LongOptionTest>({"", "--port", "one"}),
+               program::ProgramArgumentsError);
+}
+
+TEST(LongOptionTest, WillThrowOnRepeatedArgument) {
+  EXPECT_THROW(parse<LongOptionTest>({"", "--port", "8080", "--port", "443"}),
+               program::ArgumentStructureError);
+}
+
+TEST(LongOptionTest, WillThrowOnUnknownArgument) {
+  EXPECT_THROW(parse<LongOptionTest>({"", "--path", "/null"}),
+               program::NotAnArgumentError);
+}
+
+TEST(LongOptionTest, DoesNotImplicitlyShortenArgs) {
+  EXPECT_THROW(parse<LongOptionTest>({"", "-p", "443"}),
+               program::NotAnArgumentError);
+}
+
+struct LongOptionWithDefaultTest
+    : program::Arguments<LongOptionWithDefaultTest> {
+  using program::Arguments<LongOptionWithDefaultTest>::Arguments;
+
+  std::string endpoint = option("endpoint") = "/default";
+  int port = option("port") = 8080;
+};
+
+TEST(LongOptionWithDefaultTest, ArgumentsAreDefaultedNaturally) {
+  auto const options = parse<LongOptionWithDefaultTest>({""});
+  EXPECT_THAT(options.endpoint, Eq("/default"));
+  EXPECT_THAT(options.port, Eq(8080));
+}
+
+TEST(LongOptionWithDefaultTest, CanProvideStringArgument) {
+  auto const options =
+      parse<LongOptionWithDefaultTest>({"", "--endpoint", "/null"});
+  EXPECT_THAT(options.endpoint, Eq("/null"));
+}
+
+TEST(LongOptionWithDefaultTest, CanProvideNumericArgument) {
+  auto const options = parse<LongOptionWithDefaultTest>({"", "--port", "443"});
+  EXPECT_THAT(options.port, Eq(443));
+}
+
+struct LongOptionWithAbbrevTest : program::Arguments<LongOptionWithAbbrevTest> {
+  using program::Arguments<LongOptionWithAbbrevTest>::Arguments;
+
+  std::string endpoint = option("endpoint", 'e');
+  int port = option("port", 'p');
+};
+
+TEST(LongOptionWithAbbrevTest, CanProvideStringArgument) {
+  auto const options =
+      parse<LongOptionWithAbbrevTest>({"", "--endpoint", "/null"});
+  EXPECT_THAT(options.endpoint, Eq("/null"));
+}
+
+TEST(LongOptionWithAbbrevTest, CanProvideAbbrevStringArgument) {
+  auto const options = parse<LongOptionWithAbbrevTest>({"", "-e", "/null"});
+  EXPECT_THAT(options.endpoint, Eq("/null"));
+}
+
+TEST(LongOptionWithAbbrevTest, CanProvideNumericArgument) {
+  auto const options = parse<LongOptionWithAbbrevTest>({"", "--port", "443"});
+  EXPECT_THAT(options.port, Eq(443));
+}
+
+TEST(LongOptionWithAbbrevTest, CanProvideAbbrevNumericArgument) {
+  auto const options = parse<LongOptionWithAbbrevTest>({"", "-p", "443"});
+  EXPECT_THAT(options.port, Eq(443));
+}
+
+TEST(LongOptionWithAbbrevTest, ShortAndLongArgsGoToSamePool) {
+  EXPECT_THROW(
+      parse<LongOptionWithAbbrevTest>({"", "--port", "8080", "-p", "443"}),
+      program::ArgumentStructureError);
+}