#if ENABLE_UNIT_TESTS
|
|
#include "il2cpp-config.h"
|
|
#include "UnitTest++.h"
|
|
#include "../Path-c-api.h"
|
#include "../../Path.h"
|
#include "../../../utils/PathUtils.h"
|
|
SUITE(Path)
|
{
|
TEST(GetTempPathNotNull)
|
{
|
CHECK_NOT_NULL(UnityPalGetTempPath());
|
}
|
|
TEST(GetTempPathSanity)
|
{
|
// Path will never be the same depeding on user, platform,machine etc. Check if the string is
|
// at least a few chars long
|
CHECK(strlen(UnityPalGetTempPath()) > 3);
|
}
|
|
TEST(GetTempPathTestMatchesClass)
|
{
|
CHECK_EQUAL(il2cpp::os::Path::GetTempPath().c_str(), UnityPalGetTempPath());
|
}
|
|
TEST(GetExecutablePathNotNull)
|
{
|
CHECK_NOT_NULL(UnityPalGetExecutablePath());
|
}
|
|
#if !IL2CPP_TARGET_PS4 && !IL2CPP_TARGET_PS5 // PS4 doesn't have an executable path concept - it returns an empty string.
|
TEST(GetExecutablePathIsEmpty)
|
{
|
// Path will never be the same depeding on user, platform,machine etc. Check if the string is
|
// at least a few chars long
|
CHECK(strlen(UnityPalGetExecutablePath()) > 5);
|
}
|
#else
|
TEST(GetExecutablePathIsEmpty)
|
{
|
CHECK_EQUAL(UnityPalGetExecutablePath(), "");
|
}
|
#endif
|
|
TEST(GetExecutablePathMatchesClass)
|
{
|
CHECK_EQUAL(il2cpp::os::Path::GetExecutablePath().c_str(), UnityPalGetExecutablePath());
|
}
|
|
static std::string FormatExpectedAbsolutePathMessage(const char* input)
|
{
|
return std::string("The path '") + std::string(input) + std::string("' is not reported as absolute, which is not expected.");
|
}
|
|
static std::string FormatExpectedNotAbsolutePathMessage(const char* input)
|
{
|
return std::string("The path '") + std::string(input) + std::string("' is reported as absolute, which is not expected.");
|
}
|
|
enum PathType
|
{
|
kAbsolute,
|
kRelative
|
};
|
|
static void VerifyPathIs(PathType type, const char* input)
|
{
|
if (type == kAbsolute)
|
CHECK_MSG(UnityPalIsAbsolutePath(input), FormatExpectedAbsolutePathMessage(input).c_str());
|
else
|
CHECK_MSG(!UnityPalIsAbsolutePath(input), FormatExpectedNotAbsolutePathMessage(input).c_str());
|
}
|
|
TEST(PathThatIsNull_IsNotAbsolute)
|
{
|
VerifyPathIs(kRelative, NULL);
|
}
|
|
#if defined(WINDOWS)
|
TEST(PathThatIsEmpty_IsNotAbsolute)
|
{
|
VerifyPathIs(kRelative, "");
|
}
|
|
TEST(PathThatIsWithoutDriveLetter_IsNotAbsolute)
|
{
|
VerifyPathIs(kRelative, "home\test");
|
}
|
|
TEST(PathThatIsDriveLetterWithSeparator_IsNotAbsolute)
|
{
|
VerifyPathIs(kRelative, "C:");
|
}
|
|
TEST(PathThatIsDriveLetterWithBackslash_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "C:\\");
|
}
|
|
TEST(PathThatIsDriveLetterWithBackslashFollowedByAnything_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "C:\\bar");
|
}
|
|
TEST(PathThatIsDriveLetterWithForwardslash_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "C:/");
|
}
|
|
TEST(PathThatIsDoubleBackslash_IsNotAbsolute)
|
{
|
VerifyPathIs(kRelative, "\\\\");
|
}
|
|
TEST(PathThatIsDoubleBackslashFollowedByAnything_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "\\\\bar");
|
}
|
|
TEST(IsAbsoluteMatchesForAbsolutePathClass)
|
{
|
std::string input = "C:\\";
|
CHECK_EQUAL(static_cast<int32_t>(il2cpp::os::Path::IsAbsolute(input)), UnityPalIsAbsolutePath(input.c_str()));
|
}
|
|
TEST(IsAbsoluteMatchesForRelativePathClass)
|
{
|
std::string input = "test\\path";
|
CHECK_EQUAL(static_cast<int32_t>(il2cpp::os::Path::IsAbsolute(input)), UnityPalIsAbsolutePath(input.c_str()));
|
}
|
#else
|
TEST(PathThatIsOnlyForwardSlash_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "/");
|
}
|
|
TEST(PathThatStartWithForwardSlash_IsAbsolute)
|
{
|
VerifyPathIs(kAbsolute, "/test/path/foo");
|
}
|
|
TEST(PathThatDoesNotStartWithAForwardSlash_INotAbsolute)
|
{
|
VerifyPathIs(kRelative, "test/path/foo");
|
}
|
|
TEST(IsAbsoluteMatchesForAbsolutePathClass)
|
{
|
std::string input = "/home/foo";
|
CHECK_EQUAL(static_cast<int32_t>(il2cpp::os::Path::IsAbsolute(input)), UnityPalIsAbsolutePath(input.c_str()));
|
}
|
|
TEST(IsAbsoluteMatchesForRelativePathClass)
|
{
|
std::string input = "home/path";
|
CHECK_EQUAL(static_cast<int32_t>(il2cpp::os::Path::IsAbsolute(input)), UnityPalIsAbsolutePath(input.c_str()));
|
}
|
#endif
|
|
TEST(BasenameForNullPath_ReturnsNull)
|
{
|
CHECK_NULL(UnityPalBasename(NULL));
|
}
|
|
TEST(BasenameForEmptyPath_ReturnsDot)
|
{
|
char* basename = UnityPalBasename("");
|
CHECK_EQUAL(".", basename);
|
free(basename);
|
}
|
|
TEST(BasenameForEmptyPath_MatchesClass)
|
{
|
std::string input = "";
|
char* basename = UnityPalBasename(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::Basename(input), basename);
|
free(basename);
|
}
|
#if defined(WINDOWS)
|
TEST(BasenameWithBackslashes_ReturnsLastPathElement)
|
{
|
char* basename = UnityPalBasename("test\\path\\foo");
|
CHECK_EQUAL("foo", basename);
|
free(basename);
|
}
|
|
TEST(BasenameWithBackslashes_MatchesClass)
|
{
|
std::string input = "test\\path\\foo";
|
char* basename = UnityPalBasename(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::Basename(input), basename);
|
free(basename);
|
}
|
#else
|
TEST(BasenameWithForwardslashes_ReturnsLastPathElement)
|
{
|
char* basename = UnityPalBasename("test/path/foo");
|
CHECK_EQUAL("foo", basename);
|
free(basename);
|
}
|
|
TEST(BasenameWithForwardslashes_MatchesClass)
|
{
|
std::string input = "test/path/foo";
|
char* basename = UnityPalBasename(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::Basename(input), basename);
|
free(basename);
|
}
|
#endif
|
|
TEST(BasenameWithoutSeparators_ReturnsInput)
|
{
|
char* basename = UnityPalBasename("bar");
|
CHECK_EQUAL("bar", basename);
|
free(basename);
|
}
|
|
TEST(BasenameWithoutSeparators_MatchesClass)
|
{
|
std::string input = "bar";
|
char* basename = UnityPalBasename(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::Basename(input), basename);
|
free(basename);
|
}
|
|
TEST(DirectoryNameForNullPath_ReturnsNull)
|
{
|
CHECK_NULL(UnityPalDirectoryName(NULL));
|
}
|
|
TEST(DirectoryNameForEmptyPath_ReturnsEmptyString)
|
{
|
char* DirectoryName = UnityPalDirectoryName("");
|
CHECK_EQUAL("", DirectoryName);
|
free(DirectoryName);
|
}
|
|
TEST(DirectoryNameForEmptyPath_MatchesClass)
|
{
|
std::string input = "";
|
char* DirectoryName = UnityPalDirectoryName(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::DirectoryName(input), DirectoryName);
|
free(DirectoryName);
|
}
|
#if defined(WINDOWS)
|
TEST(DirectoryNameWithBackslashes_ReturnsLastPathElement)
|
{
|
char* DirectoryName = UnityPalDirectoryName("test\\path\\foo");
|
CHECK_EQUAL("test\\path", DirectoryName);
|
free(DirectoryName);
|
}
|
|
TEST(DirectoryNameWithBackslashes_MatchesClass)
|
{
|
std::string input = "test\\path\\foo";
|
char* DirectoryName = UnityPalDirectoryName(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::DirectoryName(input), DirectoryName);
|
free(DirectoryName);
|
}
|
#else
|
TEST(DirectoryNameWithForwardslashes_ReturnsLastPathElement)
|
{
|
char* DirectoryName = UnityPalDirectoryName("test/path/foo");
|
CHECK_EQUAL("test/path", DirectoryName);
|
free(DirectoryName);
|
}
|
|
TEST(DirectoryNameWithForwardslashes_MatchesClass)
|
{
|
std::string input = "test/path/foo";
|
char* DirectoryName = UnityPalDirectoryName(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::DirectoryName(input), DirectoryName);
|
free(DirectoryName);
|
}
|
#endif
|
|
TEST(DirectoryNameWithoutSeparators_ReturnsDot)
|
{
|
char* DirectoryName = UnityPalDirectoryName("bar");
|
CHECK_EQUAL(".", DirectoryName);
|
free(DirectoryName);
|
}
|
|
TEST(DirectoryNameWithoutSeparators_MatchesClass)
|
{
|
std::string input = "bar";
|
char* DirectoryName = UnityPalDirectoryName(input.c_str());
|
CHECK_EQUAL(il2cpp::utils::PathUtils::DirectoryName(input), DirectoryName);
|
free(DirectoryName);
|
}
|
}
|
|
#endif // ENABLE_UNIT_TESTS
|
