Page MenuHomePhabricator

Please use GitHub pull requests for new patches. Avoid migrating existing patches. Phabricator shutdown timeline

Differential D130475 Diff 447278 flang/unittests/Runtime/CommandTest.cpp

Changeset View

Standalone View

View Options

flang/unittests/Runtime/CommandTest.cpp

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines void CheckValue(RuntimeCall F, const char *expectedValue,
CheckDescriptorEqInt(length.get(), expectedLength); CheckDescriptorEqInt(length.get(), expectedLength);
CheckDescriptorEqStr(errmsg.get(), expectedErrMsg); CheckDescriptorEqStr(errmsg.get(), expectedErrMsg);
} }
void CheckArgumentValue(const char *expectedValue, int n) const { void CheckArgumentValue(const char *expectedValue, int n) const {
SCOPED_TRACE(n); SCOPED_TRACE(n);
SCOPED_TRACE("Checking argument:"); SCOPED_TRACE("Checking argument:");
CheckValue( CheckValue(
[&](const Descriptor *value, const Descriptor *, [&](const Descriptor *value, const Descriptor *length,
const Descriptor *errmsg) { const Descriptor *errmsg) {
return RTNAME(ArgumentValue)(n, value, errmsg); return RTNAME(GetCommandArgument)(n, value, length, errmsg);
}, },
expectedValue); expectedValue, std::strlen(expectedValue));
} }
void CheckCommandValue(const char *args[], int n) const { void CheckCommandValue(const char *args[], int n) const {
SCOPED_TRACE("Checking command:"); SCOPED_TRACE("Checking command:");
ASSERT_GE(n, 1); ASSERT_GE(n, 1);
std::string expectedValue{args[0]}; std::string expectedValue{args[0]};
for (int i = 1; i < n; i++) { for (int i = 1; i < n; i++) {
expectedValue += " " + std::string{args[i]}; expectedValue += " " + std::string{args[i]};
Show All 36 Lines CheckValue(
}, },
"", -1, 1, "Missing environment variable"); "", -1, 1, "Missing environment variable");
} }
void CheckMissingArgumentValue(int n, const char *errStr = nullptr) const { void CheckMissingArgumentValue(int n, const char *errStr = nullptr) const {
OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()}; OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
ASSERT_NE(value, nullptr); ASSERT_NE(value, nullptr);
OwningPtr<Descriptor> length{EmptyIntDescriptor()};
ASSERT_NE(length, nullptr);
OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr}; OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr};
EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), err.get()), 0); EXPECT_GT(
RTNAME(GetCommandArgument)(n, value.get(), length.get(), err.get()), 0);
std::string spaces(value->ElementBytes(), ' '); std::string spaces(value->ElementBytes(), ' ');
CheckDescriptorEqStr(value.get(), spaces); CheckDescriptorEqStr(value.get(), spaces);
CheckDescriptorEqInt(length.get(), 0);
if (errStr) { if (errStr) {
std::string paddedErrStr(GetPaddedStr(errStr, err->ElementBytes())); std::string paddedErrStr(GetPaddedStr(errStr, err->ElementBytes()));
CheckDescriptorEqStr(err.get(), paddedErrStr); CheckDescriptorEqStr(err.get(), paddedErrStr);
} }
} }
void CheckMissingCommandValue(const char *errStr = nullptr) const { void CheckMissingCommandValue(const char *errStr = nullptr) const {
OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()}; OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
Show All 30 Lines
static const char *commandOnlyArgv[]{"aProgram"}; static const char *commandOnlyArgv[]{"aProgram"};
class ZeroArguments : public CommandFixture { class ZeroArguments : public CommandFixture {
protected: protected:
ZeroArguments() : CommandFixture(1, commandOnlyArgv) {} ZeroArguments() : CommandFixture(1, commandOnlyArgv) {}
}; };
TEST_F(ZeroArguments, ArgumentCount) { EXPECT_EQ(0, RTNAME(ArgumentCount)()); } TEST_F(ZeroArguments, ArgumentCount) { EXPECT_EQ(0, RTNAME(ArgumentCount)()); }
TEST_F(ZeroArguments, ArgumentLength) { TEST_F(ZeroArguments, GetCommandArgument) {
EXPECT_EQ(0, RTNAME(ArgumentLength)(-1)); CheckMissingArgumentValue(-1);
EXPECT_EQ(8, RTNAME(ArgumentLength)(0));
EXPECT_EQ(0, RTNAME(ArgumentLength)(1));
}
TEST_F(ZeroArguments, ArgumentValue) {
CheckArgumentValue(commandOnlyArgv[0], 0); CheckArgumentValue(commandOnlyArgv[0], 0);
CheckMissingArgumentValue(1);
} }
TEST_F(ZeroArguments, GetCommand) { CheckCommandValue(commandOnlyArgv, 1); } TEST_F(ZeroArguments, GetCommand) { CheckCommandValue(commandOnlyArgv, 1); }
static const char *oneArgArgv[]{"aProgram", "anArgumentOfLength20"}; static const char *oneArgArgv[]{"aProgram", "anArgumentOfLength20"};
class OneArgument : public CommandFixture { class OneArgument : public CommandFixture {
protected: protected:
OneArgument() : CommandFixture(2, oneArgArgv) {} OneArgument() : CommandFixture(2, oneArgArgv) {}
}; };
TEST_F(OneArgument, ArgumentCount) { EXPECT_EQ(1, RTNAME(ArgumentCount)()); } TEST_F(OneArgument, ArgumentCount) { EXPECT_EQ(1, RTNAME(ArgumentCount)()); }
TEST_F(OneArgument, ArgumentLength) { TEST_F(OneArgument, GetCommandArgument) {
EXPECT_EQ(0, RTNAME(ArgumentLength)(-1)); CheckMissingArgumentValue(-1);
EXPECT_EQ(8, RTNAME(ArgumentLength)(0));
EXPECT_EQ(20, RTNAME(ArgumentLength)(1));
EXPECT_EQ(0, RTNAME(ArgumentLength)(2));
}
TEST_F(OneArgument, ArgumentValue) {
CheckArgumentValue(oneArgArgv[0], 0); CheckArgumentValue(oneArgArgv[0], 0);
CheckArgumentValue(oneArgArgv[1], 1); CheckArgumentValue(oneArgArgv[1], 1);
CheckMissingArgumentValue(2);
} }
TEST_F(OneArgument, GetCommand) { CheckCommandValue(oneArgArgv, 2); } TEST_F(OneArgument, GetCommand) { CheckCommandValue(oneArgArgv, 2); }
static const char *severalArgsArgv[]{ static const char *severalArgsArgv[]{
"aProgram", "16-char-long-arg", "", "-22-character-long-arg", "o"}; "aProgram", "16-char-long-arg", "", "-22-character-long-arg", "o"};
class SeveralArguments : public CommandFixture { class SeveralArguments : public CommandFixture {
protected: protected:
SeveralArguments() SeveralArguments()
: CommandFixture(sizeof(severalArgsArgv) / sizeof(*severalArgsArgv), : CommandFixture(sizeof(severalArgsArgv) / sizeof(*severalArgsArgv),
severalArgsArgv) {} severalArgsArgv) {}
}; };
TEST_F(SeveralArguments, ArgumentCount) { TEST_F(SeveralArguments, ArgumentCount) {
EXPECT_EQ(4, RTNAME(ArgumentCount)()); EXPECT_EQ(4, RTNAME(ArgumentCount)());
} }
TEST_F(SeveralArguments, ArgumentLength) { TEST_F(SeveralArguments, GetCommandArgument) {
EXPECT_EQ(0, RTNAME(ArgumentLength)(-1));
EXPECT_EQ(8, RTNAME(ArgumentLength)(0));
EXPECT_EQ(16, RTNAME(ArgumentLength)(1));
EXPECT_EQ(0, RTNAME(ArgumentLength)(2));
EXPECT_EQ(22, RTNAME(ArgumentLength)(3));
EXPECT_EQ(1, RTNAME(ArgumentLength)(4));
EXPECT_EQ(0, RTNAME(ArgumentLength)(5));
}
TEST_F(SeveralArguments, ArgumentValue) {
CheckArgumentValue(severalArgsArgv[0], 0); CheckArgumentValue(severalArgsArgv[0], 0);
CheckArgumentValue(severalArgsArgv[1], 1); CheckArgumentValue(severalArgsArgv[1], 1);
CheckArgumentValue(severalArgsArgv[3], 3); CheckArgumentValue(severalArgsArgv[3], 3);
CheckArgumentValue(severalArgsArgv[4], 4); CheckArgumentValue(severalArgsArgv[4], 4);
} }
TEST_F(SeveralArguments, NoArgumentValue) { TEST_F(SeveralArguments, NoArgumentValue) {
// Make sure we don't crash if the 'value' and 'error' parameters aren't // Make sure we don't crash if the 'value', 'length' and 'error' parameters
// passed. // aren't passed.
EXPECT_EQ(RTNAME(ArgumentValue)(2, nullptr, nullptr), 0); EXPECT_GT(RTNAME(GetCommandArgument)(2), 0);
EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, nullptr), 0); EXPECT_EQ(RTNAME(GetCommandArgument)(1), 0);
EXPECT_GT(RTNAME(GetCommandArgument)(-1), 0);
} }
TEST_F(SeveralArguments, MissingArguments) { TEST_F(SeveralArguments, MissingArguments) {
CheckMissingArgumentValue(-1, "Invalid argument number"); CheckMissingArgumentValue(-1, "Invalid argument number");
CheckMissingArgumentValue(2, "Missing argument"); CheckMissingArgumentValue(2, "Missing argument");
CheckMissingArgumentValue(5, "Invalid argument number"); CheckMissingArgumentValue(5, "Invalid argument number");
CheckMissingArgumentValue(5); CheckMissingArgumentValue(5);
} }
TEST_F(SeveralArguments, ArgValueTooShort) { TEST_F(SeveralArguments, ArgValueTooShort) {
OwningPtr<Descriptor> tooShort{CreateEmptyCharDescriptor<15>()}; OwningPtr<Descriptor> tooShort{CreateEmptyCharDescriptor<15>()};
ASSERT_NE(tooShort, nullptr); ASSERT_NE(tooShort, nullptr);
EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), nullptr), -1); EXPECT_EQ(RTNAME(GetCommandArgument)(1, tooShort.get()), -1);
CheckDescriptorEqStr(tooShort.get(), severalArgsArgv[1]); CheckDescriptorEqStr(tooShort.get(), severalArgsArgv[1]);
OwningPtr<Descriptor> length{EmptyIntDescriptor()};
ASSERT_NE(length, nullptr);
OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor()}; OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor()};
ASSERT_NE(errMsg, nullptr); ASSERT_NE(errMsg, nullptr);
EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), errMsg.get()), -1); EXPECT_EQ(
RTNAME(GetCommandArgument)(1, tooShort.get(), length.get(), errMsg.get()),
-1);
CheckDescriptorEqInt(length.get(), 16);
std::string expectedErrMsg{ std::string expectedErrMsg{
GetPaddedStr("Value too short", errMsg->ElementBytes())}; GetPaddedStr("Value too short", errMsg->ElementBytes())};
CheckDescriptorEqStr(errMsg.get(), expectedErrMsg); CheckDescriptorEqStr(errMsg.get(), expectedErrMsg);
} }
TEST_F(SeveralArguments, ArgErrMsgTooShort) { TEST_F(SeveralArguments, ArgErrMsgTooShort) {
OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()}; OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, errMsg.get()), 0); EXPECT_GT(RTNAME(GetCommandArgument)(-1, nullptr, nullptr, errMsg.get()), 0);
CheckDescriptorEqStr(errMsg.get(), "Inv"); CheckDescriptorEqStr(errMsg.get(), "Inv");
} }
TEST_F(SeveralArguments, GetCommand) { TEST_F(SeveralArguments, GetCommand) {
CheckMissingCommandValue(); CheckMissingCommandValue();
CheckMissingCommandValue("Missing argument"); CheckMissingCommandValue("Missing argument");
} }
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines