cpp-argument-parser/test/argument_test.cpp

//
//  argument_test.cpp
//  program_args-test
//
//  Created by Sam Jaffe on 2/7/21.
//

#include "program_args/arguments.h"

#include "xcode_gtest_helper.h"

using testing::ElementsAre;
using testing::Eq;

template <typename T, size_t N> static T parse(char const * const (&argv)[N]) {
  return T(N, argv);
}

struct ArgumentTest : program::Arguments<ArgumentTest> {
  using program::Arguments<ArgumentTest>::Arguments;

  std::string arg0 = argument(0, "arg0");
};

TEST(ArgumentTest, ThrowsIfMissingArg) {
  EXPECT_THROW(parse<ArgumentTest>({""}), program::IllegalPositionError);
}

TEST(ArgumentTest, ProcessesArgument) {
  auto const options = parse<ArgumentTest>({"", "value"});
  EXPECT_THAT(options.arg0, Eq("value"));
}

TEST(ArgumentTest, HasNoIssueWithOverflowArg) {
  auto const options = parse<ArgumentTest>({"", "value", "extra"});
  EXPECT_THAT(options.arg0, Eq("value"));
  EXPECT_THAT(options.args(), ElementsAre("extra"));
}

struct OptionalArgumentTest : program::Arguments<OptionalArgumentTest> {
  using program::Arguments<OptionalArgumentTest>::Arguments;

  std::string arg0 = argument(0, "arg0");
  std::string arg1 = argument(1, "arg1") = "second";
};

TEST(OptionalArgumentTest, DoesNotRequireOptionalArg) {
  EXPECT_NO_THROW(parse<OptionalArgumentTest>({"", "value"}));
}

TEST(OptionalArgumentTest, DefaultsOutValueAsExpected) {
  auto const options = parse<OptionalArgumentTest>({"", "value"});
  EXPECT_THAT(options.arg1, Eq("second"));
}

TEST(OptionalArgumentTest, DoesNotOverflowSecondArg) {
  auto const options = parse<OptionalArgumentTest>({"", "value", "extra"});
  EXPECT_THAT(options.arg0, Eq("value"));
  EXPECT_THAT(options.arg1, Eq("extra"));
  EXPECT_THAT(options.args(), ElementsAre());
}

struct DuplicateArgumentTest : program::Arguments<DuplicateArgumentTest> {
  using program::Arguments<DuplicateArgumentTest>::Arguments;

  std::string arg0 = argument(0, "arg0");
  std::string arg1 = argument(0, "arg1");
};

TEST(DuplicateArgumentTest, ThrowsOnConstruction) {
  EXPECT_THROW(DuplicateArgumentTest(), program::IllegalPositionError);
}

struct SkippedArgumentTest : program::Arguments<SkippedArgumentTest> {
  using program::Arguments<SkippedArgumentTest>::Arguments;

  std::string arg0 = argument(1, "arg0");
};

TEST(SkippedArgumentTest, ThrowsOnParsing) {
  EXPECT_NO_THROW(SkippedArgumentTest());
  EXPECT_THROW(parse<SkippedArgumentTest>({"", "", ""}),
               program::IllegalPositionError);
}

struct OOOArgumentTest : program::Arguments<OOOArgumentTest> {
  using program::Arguments<OOOArgumentTest>::Arguments;

  std::string arg0 = argument(0, "arg0") = "";
  std::string arg1 = argument(1, "arg1");
};

TEST(OOOArgumentTest, ThrowsOnConstruction) {
  EXPECT_THROW(OOOArgumentTest(), program::ArgumentStructureError);
}