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

Differential D118777 Diff 411088 flang/unittests/Runtime/CommandTest.cpp

Changeset View

Standalone View

flang/unittests/Runtime/CommandTest.cpp

Show All 30 Lines	OwningPtr<Descriptor> descriptor{Descriptor::Create(
sizeof(char), n, nullptr, 0, nullptr, CFI_attribute_allocatable)};		sizeof(char), n, nullptr, 0, nullptr, CFI_attribute_allocatable)};
if (descriptor->Allocate() != 0) {		if (descriptor->Allocate() != 0) {
return nullptr;		return nullptr;
}		}
std::memcpy(descriptor->OffsetElement(), value, n);		std::memcpy(descriptor->OffsetElement(), value, n);
return descriptor;		return descriptor;
}		}

		template <int kind = sizeof(std::int64_t)>
		static OwningPtr<Descriptor> EmptyIntDescriptor() {
		OwningPtr<Descriptor> descriptor{Descriptor::Create(TypeCategory::Integer,
		kind, nullptr, 0, nullptr, CFI_attribute_allocatable)};
		if (descriptor->Allocate() != 0) {
		return nullptr;
		}
		return descriptor;
		}

class CommandFixture : public ::testing::Test {		class CommandFixture : public ::testing::Test {
protected:		protected:
CommandFixture(int argc, const char *argv[]) {		CommandFixture(int argc, const char *argv[]) {
RTNAME(ProgramStart)(argc, argv, {});		RTNAME(ProgramStart)(argc, argv, {});
}		}

std::string GetPaddedStr(const char *text, std::size_t len) const {		std::string GetPaddedStr(const char *text, std::size_t len) const {
std::string res{text};		std::string res{text};
assert(res.length() <= len && "No room to pad");		assert(res.length() <= len && "No room to pad");
res.append(len - res.length(), ' ');		res.append(len - res.length(), ' ');
return res;		return res;
}		}

void CheckDescriptorEqStr(		void CheckDescriptorEqStr(
const Descriptor *value, const std::string &expected) const {		const Descriptor *value, const std::string &expected) const {
		ASSERT_NE(value, nullptr);
EXPECT_EQ(std::strncmp(value->OffsetElement(), expected.c_str(),		EXPECT_EQ(std::strncmp(value->OffsetElement(), expected.c_str(),
value->ElementBytes()),		value->ElementBytes()),
0)		0)
<< "expected: " << expected << "\n"		<< "expected: " << expected << "\n"
<< "value: "		<< "value: "
<< std::string{value->OffsetElement(), value->ElementBytes()};		<< std::string{value->OffsetElement(), value->ElementBytes()};
}		}

		void CheckDescriptorEqInt(
		const Descriptor *value, const std::int64_t expected) const {
		if (expected != -1) {
		ASSERT_NE(value, nullptr);
		EXPECT_EQ(*value->OffsetElement<std::int64_t>(), expected);
		}
		}

template <typename RuntimeCall>		template <typename RuntimeCall>
void CheckValue(RuntimeCall F, const char *expectedValue,		void CheckValue(RuntimeCall F, const char *expectedValue,
std::int32_t expectedStatus = 0,		std::int64_t expectedLength = -1, std::int32_t expectedStatus = 0,
const char *expectedErrMsg = "shouldn't change") const {		const char *expectedErrMsg = "shouldn't change") const {
OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};		OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
ASSERT_NE(value, nullptr);		ASSERT_NE(value, nullptr);

		OwningPtr<Descriptor> length{
		expectedLength == -1 ? nullptr : EmptyIntDescriptor()};

OwningPtr<Descriptor> errmsg{CharDescriptor(expectedErrMsg)};		OwningPtr<Descriptor> errmsg{CharDescriptor(expectedErrMsg)};
		ASSERT_NE(errmsg, nullptr);

std::string expectedValueStr{		std::string expectedValueStr{
GetPaddedStr(expectedValue, value->ElementBytes())};		GetPaddedStr(expectedValue, value->ElementBytes())};

EXPECT_EQ(F(value.get(), errmsg.get()), expectedStatus);		EXPECT_EQ(F(value.get(), length.get(), errmsg.get()), expectedStatus);
CheckDescriptorEqStr(value.get(), expectedValueStr);		CheckDescriptorEqStr(value.get(), expectedValueStr);
		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 errmsg) {		[&](const Descriptor value, const Descriptor ,
		const Descriptor *errmsg) {
return RTNAME(ArgumentValue)(n, value, errmsg);		return RTNAME(ArgumentValue)(n, value, errmsg);
},		},
expectedValue);		expectedValue);
}		}

		void CheckCommandValue(const char *args[], int n) const {
		SCOPED_TRACE("Checking command:");
		ASSERT_GE(n, 1);
		std::string expectedValue{args[0]};
		for (int i = 1; i < n; i++) {
		expectedValue += " " + std::string{args[i]};
		}
		CheckValue(
		[&](const Descriptor value, const Descriptor length,
		const Descriptor *errmsg) {
		return RTNAME(GetCommand)(value, length, errmsg);
		},
		expectedValue.c_str(), expectedValue.size());
		}

void CheckEnvVarValue(		void CheckEnvVarValue(
const char expectedValue, const char name, bool trimName = true) const {		const char expectedValue, const char name, bool trimName = true) const {
SCOPED_TRACE(name);		SCOPED_TRACE(name);
SCOPED_TRACE("Checking environment variable");		SCOPED_TRACE("Checking environment variable");
CheckValue(		CheckValue(
[&](const Descriptor value, const Descriptor errmsg) {		[&](const Descriptor value, const Descriptor ,
		const Descriptor *errmsg) {
return RTNAME(EnvVariableValue)(*CharDescriptor(name), value,		return RTNAME(EnvVariableValue)(*CharDescriptor(name), value,
trimName, errmsg, /sourceFile=/nullptr, /line=/0);		trimName, errmsg, /sourceFile=/nullptr, /line=/0);
},		},
expectedValue);		expectedValue);
}		}

void CheckMissingEnvVarValue(const char *name, bool trimName = true) const {		void CheckMissingEnvVarValue(const char *name, bool trimName = true) const {
SCOPED_TRACE(name);		SCOPED_TRACE(name);
SCOPED_TRACE("Checking missing environment variable");		SCOPED_TRACE("Checking missing environment variable");

ASSERT_EQ(nullptr, std::getenv(name))		ASSERT_EQ(nullptr, std::getenv(name))
<< "Environment variable " << name << " not expected to exist";		<< "Environment variable " << name << " not expected to exist";

OwningPtr<Descriptor> nameDescriptor{CharDescriptor(name)};		OwningPtr<Descriptor> nameDescriptor{CharDescriptor(name)};
EXPECT_EQ(0, RTNAME(EnvVariableLength)(*nameDescriptor, trimName));		EXPECT_EQ(0, RTNAME(EnvVariableLength)(*nameDescriptor, trimName));
CheckValue(		CheckValue(
[&](const Descriptor value, const Descriptor errmsg) {		[&](const Descriptor value, const Descriptor ,
		const Descriptor *errmsg) {
return RTNAME(EnvVariableValue)(*nameDescriptor, value, trimName,		return RTNAME(EnvVariableValue)(*nameDescriptor, value, trimName,
errmsg, /sourceFile=/nullptr, /line=/0);		errmsg, /sourceFile=/nullptr, /line=/0);
},		},
"", 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> err{errStr ? CreateEmptyCharDescriptor() : nullptr};		OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr};

EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), err.get()), 0);		EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), err.get()), 0);

std::string spaces(value->ElementBytes(), ' ');		std::string spaces(value->ElementBytes(), ' ');
CheckDescriptorEqStr(value.get(), spaces);		CheckDescriptorEqStr(value.get(), spaces);

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 {
		OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
		ASSERT_NE(value, nullptr);

		OwningPtr<Descriptor> length{EmptyIntDescriptor()};
		ASSERT_NE(length, nullptr);

		OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr};

		EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), err.get()), 0);

		std::string spaces(value->ElementBytes(), ' ');
		CheckDescriptorEqStr(value.get(), spaces);

		CheckDescriptorEqInt(length.get(), 0);

		if (errStr) {
		std::string paddedErrStr(GetPaddedStr(errStr, err->ElementBytes()));
		CheckDescriptorEqStr(err.get(), paddedErrStr);
		}
		}
		};

		class NoArgv : public CommandFixture {
		protected:
		NoArgv() : CommandFixture(0, nullptr) {}
};		};

		// TODO: Test other intrinsics with this fixture.

		TEST_F(NoArgv, GetCommand) { CheckMissingCommandValue(); }

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, ArgumentLength) {
EXPECT_EQ(0, RTNAME(ArgumentLength)(-1));		EXPECT_EQ(0, RTNAME(ArgumentLength)(-1));
EXPECT_EQ(8, RTNAME(ArgumentLength)(0));		EXPECT_EQ(8, RTNAME(ArgumentLength)(0));
EXPECT_EQ(0, RTNAME(ArgumentLength)(1));		EXPECT_EQ(0, RTNAME(ArgumentLength)(1));
}		}

TEST_F(ZeroArguments, ArgumentValue) {		TEST_F(ZeroArguments, ArgumentValue) {
CheckArgumentValue(commandOnlyArgv[0], 0);		CheckArgumentValue(commandOnlyArgv[0], 0);
}		}

		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, ArgumentLength) {
EXPECT_EQ(0, RTNAME(ArgumentLength)(-1));		EXPECT_EQ(0, RTNAME(ArgumentLength)(-1));
EXPECT_EQ(8, RTNAME(ArgumentLength)(0));		EXPECT_EQ(8, RTNAME(ArgumentLength)(0));
EXPECT_EQ(20, RTNAME(ArgumentLength)(1));		EXPECT_EQ(20, RTNAME(ArgumentLength)(1));
EXPECT_EQ(0, RTNAME(ArgumentLength)(2));		EXPECT_EQ(0, RTNAME(ArgumentLength)(2));
}		}

TEST_F(OneArgument, ArgumentValue) {		TEST_F(OneArgument, ArgumentValue) {
CheckArgumentValue(oneArgArgv[0], 0);		CheckArgumentValue(oneArgArgv[0], 0);
CheckArgumentValue(oneArgArgv[1], 1);		CheckArgumentValue(oneArgArgv[1], 1);
}		}

		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) {}
};		};
Show All 28 Lines

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, ValueTooShort) {		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(ArgumentValue)(1, tooShort.get(), nullptr), -1);
CheckDescriptorEqStr(tooShort.get(), severalArgsArgv[1]);		CheckDescriptorEqStr(tooShort.get(), severalArgsArgv[1]);

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(ArgumentValue)(1, tooShort.get(), errMsg.get()), -1);

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, ErrMsgTooShort) {		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(ArgumentValue)(-1, nullptr, errMsg.get()), 0);
CheckDescriptorEqStr(errMsg.get(), "Inv");		CheckDescriptorEqStr(errMsg.get(), "Inv");
}		}

		TEST_F(SeveralArguments, GetCommand) {
		CheckMissingCommandValue();
		CheckMissingCommandValue("Missing argument");
		}

		TEST_F(SeveralArguments, CommandErrMsgTooShort) {
		OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
		OwningPtr<Descriptor> length{EmptyIntDescriptor()};
		OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};

		EXPECT_GT(RTNAME(GetCommand)(value.get(), length.get(), errMsg.get()), 0);

		std::string spaces(value->ElementBytes(), ' ');
		CheckDescriptorEqStr(value.get(), spaces);
		CheckDescriptorEqInt(length.get(), 0);
		CheckDescriptorEqStr(errMsg.get(), "Mis");
		}

		TEST_F(SeveralArguments, GetCommandCanTakeNull) {
		EXPECT_GT(RTNAME(GetCommand)(nullptr, nullptr, nullptr), 0);
		}

		static const char *onlyValidArgsArgv[]{
		"aProgram", "-f", "has/a/few/slashes", "has\\a\\few\\backslashes"};
		class OnlyValidArguments : public CommandFixture {
		protected:
		OnlyValidArguments()
		: CommandFixture(sizeof(onlyValidArgsArgv) / sizeof(*onlyValidArgsArgv),
		onlyValidArgsArgv) {}
		};

		TEST_F(OnlyValidArguments, GetCommand) {
		CheckCommandValue(onlyValidArgsArgv, 4);
		}

		TEST_F(OnlyValidArguments, CommandValueTooShort) {
		OwningPtr<Descriptor> tooShort{CreateEmptyCharDescriptor<50>()};
		ASSERT_NE(tooShort, nullptr);
		OwningPtr<Descriptor> length{EmptyIntDescriptor()};
		ASSERT_NE(length, nullptr);

		EXPECT_EQ(RTNAME(GetCommand)(tooShort.get(), length.get(), nullptr), -1);

		CheckDescriptorEqStr(
		tooShort.get(), "aProgram -f has/a/few/slashes has\\a\\few\\backslashe");
		CheckDescriptorEqInt(length.get(), 51);

		OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor()};
		ASSERT_NE(errMsg, nullptr);

		EXPECT_EQ(-1, RTNAME(GetCommand)(tooShort.get(), nullptr, errMsg.get()));

		std::string expectedErrMsg{
		GetPaddedStr("Value too short", errMsg->ElementBytes())};
		CheckDescriptorEqStr(errMsg.get(), expectedErrMsg);
		}

		TEST_F(OnlyValidArguments, GetCommandCanTakeNull) {
		EXPECT_EQ(0, RTNAME(GetCommand)(nullptr, nullptr, nullptr));

		OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
		ASSERT_NE(value, nullptr);
		OwningPtr<Descriptor> length{EmptyIntDescriptor()};
		ASSERT_NE(length, nullptr);

		EXPECT_EQ(0, RTNAME(GetCommand)(value.get(), nullptr, nullptr));
		CheckDescriptorEqStr(value.get(),
		GetPaddedStr("aProgram -f has/a/few/slashes has\\a\\few\\backslashes",
		value->ElementBytes()));

		EXPECT_EQ(0, RTNAME(GetCommand)(nullptr, length.get(), nullptr));
		CheckDescriptorEqInt(length.get(), 51);
		}

		TEST_F(OnlyValidArguments, GetCommandShortLength) {
		OwningPtr<Descriptor> length{EmptyIntDescriptor<sizeof(short)>()};
		ASSERT_NE(length, nullptr);

		EXPECT_EQ(0, RTNAME(GetCommand)(nullptr, length.get(), nullptr));
		CheckDescriptorEqInt(length.get(), 51);
		jeanPerierUnsubmitted Not Done Reply Inline Actions This test seems to fail on windows, see the build bot: Note: Google Test filter = OnlyValidArguments.GetCommandShortLength [==========] Running 1 test from 1 test suite. [----------] Global test environment set-up. [----------] 1 test from OnlyValidArguments [ RUN ] OnlyValidArguments.GetCommandShortLength C:\ws\w2\llvm-project\premerge-checks\flang\unittests\Runtime\CommandTest.cpp(77): error: Expected equality of these values: value->OffsetElement<std::int64_t>() Which is: 8589934643 expected Which is: 51 I think the `value->OffsetElement<std::int64_t>()` in `CheckDescriptorEqInt` may be undefined behavior if the integer type in `value` is not an `std::int64_t` (like here where it is a short). jeanPerier:* This test seems to fail on windows, see the build bot: ``` Note: Google Test filter =…
		rovkaAuthorUnsubmitted Done Reply Inline Actions Oops, I thought I had looked at the premerge checks for this one, but it must've slipped my mind 😳 Thanks for looking into it. rovka: Oops, I thought I had looked at the premerge checks for this one, but it must've slipped my…
		}

class EnvironmentVariables : public CommandFixture {		class EnvironmentVariables : public CommandFixture {
protected:		protected:
EnvironmentVariables() : CommandFixture(0, nullptr) {		EnvironmentVariables() : CommandFixture(0, nullptr) {
SetEnv("NAME", "VALUE");		SetEnv("NAME", "VALUE");
SetEnv("EMPTY", "");		SetEnv("EMPTY", "");
}		}

// If we have access to setenv, we can run some more fine-grained tests.		// If we have access to setenv, we can run some more fine-grained tests.
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines