cpp-argument-parser/test/flag_test.cpp

//
//  flag_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::Eq;

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

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

  bool dry_run = flag("dry-run");
  int verbosity = flag("verbose");
};

TEST(FlagTest, ArgumentsAreDefaultedNaturally) {
  auto const options = parse<FlagTest>({""});
  EXPECT_THAT(options.dry_run, Eq(false));
  EXPECT_THAT(options.verbosity, Eq(0));
}

TEST(FlagTest, FlagsDoNotRequireAdditionalArguments) {
  EXPECT_NO_THROW(parse<FlagTest>({"", "--dry-run"}));
}

TEST(FlagTest, BooleanFlagSetsState) {
  auto const options = parse<FlagTest>({"", "--dry-run"});
  EXPECT_THAT(options.dry_run, Eq(true));
}

TEST(FlagTest, BooleanFlagIsIdempotent) {
  EXPECT_NO_THROW(parse<FlagTest>({"", "--dry-run", "--dry-run"}));
}

TEST(FlagTest, BooleanFlagCanBeInverted) {
  auto const options = parse<FlagTest>({"", "--dry-run", "--no-dry-run"});
  EXPECT_THAT(options.dry_run, Eq(false));
}

TEST(FlagTest, IntegerFlagIncrementsState) {
  auto const options = parse<FlagTest>({"", "--verbose"});
  EXPECT_THAT(options.verbosity, Eq(1));
}

TEST(FlagTest, IntegerFlagCanBeRepeated) {
  auto const options = parse<FlagTest>({"", "--verbose", "--verbose"});
  EXPECT_THAT(options.verbosity, Eq(2));
}

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

  bool dry_run = flag("dry-run") = true;
};

TEST(FlagWithDefaultTest, ArgumentsAreDefaultedToValue) {
  auto const options = parse<FlagWithDefaultTest>({""});
  EXPECT_THAT(options.dry_run, Eq(true));
}

TEST(FlagWithDefaultTest, BooleanFlagCanBeInverted) {
  auto const options = parse<FlagWithDefaultTest>({"", "--no-dry-run"});
  EXPECT_THAT(options.dry_run, Eq(false));
}

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

  bool dry_run = flag("dry-run", 'k');
  int verbosity = flag("verbose", 'v');
};

TEST(FlagWithAbbrevTest, BooleanFlagSetsState) {
  auto const options = parse<FlagWithAbbrevTest>({"", "-k"});
  EXPECT_THAT(options.dry_run, Eq(true));
}

TEST(FlagWithAbbrevTest, IntegerFlagIncrementsState) {
  auto const options = parse<FlagWithAbbrevTest>({"", "-v"});
  EXPECT_THAT(options.verbosity, Eq(1));
}

TEST(FlagWithAbbrevTest, CanComposeTogetherAbbreviatedFlags) {
  auto const options = parse<FlagWithAbbrevTest>({"", "-vk"});
  EXPECT_THAT(options.dry_run, Eq(true));
  EXPECT_THAT(options.verbosity, Eq(1));
}

TEST(FlagWithAbbrevTest, CanComposeTogetherSameAbbrevFlags) {
  auto const options = parse<FlagWithAbbrevTest>({"", "-vv"});
  EXPECT_THAT(options.verbosity, Eq(2));
}

TEST(FlagWithAbbrevTest, CanNumberRepeatAbbrevFlags) {
  auto const options = parse<FlagWithAbbrevTest>({"", "-v3"});
  EXPECT_THAT(options.verbosity, Eq(3));
}

TEST(FlagWithAbbrevTest, CannotNumberRepeatAndConcatAbbrevFlags) {
  EXPECT_THROW(parse<FlagWithAbbrevTest>({"", "-v3k"}),
               program::NotAnArgumentError);
}

struct ShortFlagTest : program::Arguments<ShortFlagTest> {
  using Arguments::Arguments;
  int arg = flag('n');
};

TEST(ShortFlagTest, DoesNotAllowDoubleDash) {
  EXPECT_THROW(parse<ShortFlagTest>({"", "--n"}), program::NotAnArgumentError);
}

TEST(ShortFlagTest, CanConstructWithOnlyAbbrev) {
  auto const options = parse<ShortFlagTest>({"", "-n"});
  EXPECT_THAT(options.arg, 1);
}