blob: 6a743b6e416af8a9db8a2bef9655567625039f3a [file] [edit]
//===- OptionParserTest.cpp -----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "orc-rt-internal/tools/OptionParser.h"
#include "orc-rt/support/Error.h"
#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
using namespace orc_rt;
class OptionParserTest : public ::testing::Test {
protected:
std::string Host;
int Port = 0;
bool Verbose = false;
bool Help = false;
OptionParser Parser;
void SetUp() override {
Parser.addValue("host", "Hostname", std::string("localhost"), Host,
OptionParser::OptionKind::Value, 'h');
Parser.addFlag("help", "Display this help message", false, Help, '?');
Parser.addValue("port", "Port number", 8080, Port,
OptionParser::OptionKind::Value, 'p');
Parser.addFlag("verbose", "Enable verbose logging", false, Verbose, 'v');
}
};
TEST_F(OptionParserTest, NoopTest) {
OptionParser Parser;
const char *Argv[] = {""};
auto Err = Parser.parse(std::begin(Argv), std::end(Argv));
EXPECT_FALSE(!!Err);
}
TEST_F(OptionParserTest, ValueRequired) {
const char *Argv[] = {"--host"};
auto Err = Parser.parse(std::begin(Argv), std::end(Argv));
if (!Err) {
ADD_FAILURE() << "--host requires a value, shouldn't succeed.";
} else {
orc_rt::consumeError(std::move(Err));
}
}
TEST_F(OptionParserTest, UnknownOption) {
const char *Argv[] = {"--unknown=foo"};
auto Err = Parser.parse(std::begin(Argv), std::end(Argv));
if (!Err) {
ADD_FAILURE() << "unknown option, shouldn't succeed.";
} else {
orc_rt::consumeError(std::move(Err));
}
}
TEST_F(OptionParserTest, InvalidInteger) {
const char *Argv[] = {"--port=not_a_number"};
auto Err = Parser.parse(std::begin(Argv), std::end(Argv));
if (!Err) {
ADD_FAILURE() << "Invalid integer, shouldn't succeed.";
} else {
orc_rt::consumeError(std::move(Err));
}
}
TEST_F(OptionParserTest, ParseFullConfiguration) {
const char *Argv[] = {"--host=example.com", "--port=8080", "--verbose=true"};
cantFail(Parser.parse(std::begin(Argv), std::end(Argv)));
EXPECT_EQ(Host, "example.com");
EXPECT_EQ(Port, 8080);
EXPECT_EQ(Verbose, true);
}
TEST_F(OptionParserTest, ShortFlagClustering) {
const char *Argv[] = {"-v?"};
cantFail(Parser.parse(std::begin(Argv), std::end(Argv)));
EXPECT_TRUE(Verbose);
EXPECT_TRUE(Help);
}
TEST_F(OptionParserTest, ShortFlagWithValue) {
const char *Argv[] = {"-p", "1234", "-hlocalhost"};
cantFail(Parser.parse(std::begin(Argv), std::end(Argv)));
EXPECT_EQ(Port, 1234);
EXPECT_EQ(Host, "localhost");
}
TEST_F(OptionParserTest, ClusterWithValueAtEnd) {
const char *Argv[] = {"-vp9999"};
cantFail(Parser.parse(std::begin(Argv), std::end(Argv)));
EXPECT_TRUE(Verbose);
EXPECT_EQ(Port, 9999);
}
TEST_F(OptionParserTest, DoubleDashTerminatesOptionParsing) {
const char *Argv[] = {"-v", "--", "-p", "1234"};
cantFail(Parser.parse(std::begin(Argv), std::end(Argv)));
EXPECT_TRUE(Verbose);
EXPECT_EQ(Port, 8080); // Should remain default
ASSERT_EQ(Parser.positionals().size(), 2u);
EXPECT_EQ(Parser.positionals()[0], "-p");
EXPECT_EQ(Parser.positionals()[1], "1234");
}
TEST_F(OptionParserTest, ParseAsMainWithEmptyArgsSucceeds) {
const char *Argv[] = {"appname"};
auto Err = Parser.parseAsMainArgs(std::size(Argv), const_cast<char **>(Argv));
EXPECT_FALSE(!!Err);
}
TEST_F(OptionParserTest, ParseAsMainWithRegularArgsSucceeds) {
const char *Argv[] = {"appname", "-v", "--", "-p", "1234"};
cantFail(Parser.parseAsMainArgs(std::size(Argv), const_cast<char **>(Argv)));
EXPECT_TRUE(Verbose);
EXPECT_EQ(Port, 8080); // Should remain default
ASSERT_EQ(Parser.positionals().size(), 2u);
EXPECT_EQ(Parser.positionals()[0], "-p");
EXPECT_EQ(Parser.positionals()[1], "1234");
}
TEST_F(OptionParserTest, ParseAsMainWithEmptyListFails) {
std::vector<char *> Argv;
auto Err = Parser.parseAsMainArgs(static_cast<int>(Argv.size()), Argv.data());
EXPECT_TRUE(!!Err);
consumeError(std::move(Err));
}
TEST_F(OptionParserTest, PrintHelpAlignmentWithShortFlags) {
std::string LogFile;
Parser.addValue("log-file", "Path to log", std::string("out.log"), LogFile);
std::string Result = Parser.formatHelp("appname");
auto GetColumn = [&](std::string_view SearchTerm) -> size_t {
size_t Pos = Result.find(SearchTerm);
if (Pos == std::string::npos)
return 0;
size_t LineStart = Result.rfind('\n', Pos);
return (LineStart == std::string::npos) ? Pos : (Pos - LineStart - 1);
};
size_t PortDescCol = GetColumn("Port number");
size_t LogDescCol = GetColumn("Path to log");
size_t VerbDescCol = GetColumn("Enable verbose");
ASSERT_NE(PortDescCol, 0u);
EXPECT_EQ(PortDescCol, LogDescCol)
<< "Descriptions should align even if short flag is missing";
EXPECT_EQ(LogDescCol, VerbDescCol);
size_t LogFlagPos = Result.find("--log-file");
size_t PortFlagPos = Result.find("--port");
size_t LogFlagCol = (LogFlagPos - Result.rfind('\n', LogFlagPos) - 1);
size_t PortFlagCol = (PortFlagPos - Result.rfind('\n', PortFlagPos) - 1);
EXPECT_EQ(LogFlagCol, PortFlagCol);
}