134 lines
4.8 KiB
C++
134 lines
4.8 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include <XCEngine/Scripting/Mono/MonoScriptRuntime.h>
|
|
|
|
#include <algorithm>
|
|
#include <filesystem>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
using namespace XCEngine::Scripting;
|
|
|
|
namespace {
|
|
|
|
std::filesystem::path GetExecutableDirectory() {
|
|
#ifdef _WIN32
|
|
std::wstring buffer(MAX_PATH, L'\0');
|
|
const DWORD length = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
|
|
if (length == 0 || length >= buffer.size()) {
|
|
return std::filesystem::current_path();
|
|
}
|
|
|
|
buffer.resize(length);
|
|
return std::filesystem::path(buffer).parent_path();
|
|
#else
|
|
return std::filesystem::current_path();
|
|
#endif
|
|
}
|
|
|
|
std::filesystem::path ResolveProjectManagedOutputDirectory() {
|
|
constexpr const char* configuredDirectory = XCENGINE_TEST_PROJECT_MANAGED_OUTPUT_DIR;
|
|
if (configuredDirectory[0] != '\0') {
|
|
return std::filesystem::path(configuredDirectory);
|
|
}
|
|
|
|
return (GetExecutableDirectory() / ".." / ".." / "managed" / "ProjectScriptAssemblies").lexically_normal();
|
|
}
|
|
|
|
std::filesystem::path ResolveProjectScriptCoreDllPath() {
|
|
constexpr const char* configuredPath = XCENGINE_TEST_PROJECT_SCRIPT_CORE_DLL;
|
|
if (configuredPath[0] != '\0') {
|
|
return std::filesystem::path(configuredPath);
|
|
}
|
|
|
|
return ResolveProjectManagedOutputDirectory() / "XCEngine.ScriptCore.dll";
|
|
}
|
|
|
|
std::filesystem::path ResolveProjectGameScriptsDllPath() {
|
|
constexpr const char* configuredPath = XCENGINE_TEST_PROJECT_GAME_SCRIPTS_DLL;
|
|
if (configuredPath[0] != '\0') {
|
|
return std::filesystem::path(configuredPath);
|
|
}
|
|
|
|
return ResolveProjectManagedOutputDirectory() / "GameScripts.dll";
|
|
}
|
|
|
|
MonoScriptRuntime::Settings CreateProjectMonoSettings() {
|
|
MonoScriptRuntime::Settings settings;
|
|
settings.assemblyDirectory = ResolveProjectManagedOutputDirectory();
|
|
settings.corlibDirectory = settings.assemblyDirectory;
|
|
settings.coreAssemblyPath = ResolveProjectScriptCoreDllPath();
|
|
settings.appAssemblyPath = ResolveProjectGameScriptsDllPath();
|
|
return settings;
|
|
}
|
|
|
|
class ProjectScriptAssemblyTest : public ::testing::Test {
|
|
protected:
|
|
void SetUp() override {
|
|
ASSERT_TRUE(std::filesystem::exists(ResolveProjectScriptCoreDllPath()));
|
|
ASSERT_TRUE(std::filesystem::exists(ResolveProjectGameScriptsDllPath()));
|
|
|
|
runtime = std::make_unique<MonoScriptRuntime>(CreateProjectMonoSettings());
|
|
ASSERT_TRUE(runtime->Initialize()) << runtime->GetLastError();
|
|
}
|
|
|
|
std::unique_ptr<MonoScriptRuntime> runtime;
|
|
};
|
|
|
|
TEST_F(ProjectScriptAssemblyTest, InitializesFromProjectScriptAssemblyDirectory) {
|
|
EXPECT_TRUE(runtime->IsInitialized());
|
|
EXPECT_EQ(runtime->GetSettings().assemblyDirectory, ResolveProjectManagedOutputDirectory());
|
|
EXPECT_EQ(runtime->GetSettings().appAssemblyPath, ResolveProjectGameScriptsDllPath());
|
|
}
|
|
|
|
TEST_F(ProjectScriptAssemblyTest, DiscoversProjectAssetMonoBehaviourClassesAndFieldMetadata) {
|
|
const std::vector<std::string> classNames = runtime->GetScriptClassNames("GameScripts");
|
|
std::vector<ScriptClassDescriptor> classDescriptors;
|
|
ASSERT_TRUE(runtime->TryGetAvailableScriptClasses(classDescriptors));
|
|
|
|
EXPECT_TRUE(runtime->IsClassAvailable("GameScripts", "ProjectScripts", "ProjectScriptProbe"));
|
|
EXPECT_NE(
|
|
std::find(classNames.begin(), classNames.end(), "ProjectScripts.ProjectScriptProbe"),
|
|
classNames.end());
|
|
EXPECT_NE(
|
|
std::find(
|
|
classDescriptors.begin(),
|
|
classDescriptors.end(),
|
|
ScriptClassDescriptor{"GameScripts", "ProjectScripts", "ProjectScriptProbe"}),
|
|
classDescriptors.end());
|
|
|
|
std::vector<ScriptFieldMetadata> fields;
|
|
ASSERT_TRUE(runtime->TryGetClassFieldMetadata("GameScripts", "ProjectScripts", "ProjectScriptProbe", fields));
|
|
|
|
const std::vector<ScriptFieldMetadata> expectedFields = {
|
|
{"EnabledOnBoot", ScriptFieldType::Bool},
|
|
{"Label", ScriptFieldType::String},
|
|
{"Speed", ScriptFieldType::Float},
|
|
};
|
|
|
|
EXPECT_EQ(fields, expectedFields);
|
|
|
|
std::vector<ScriptFieldDefaultValue> defaultValues;
|
|
ASSERT_TRUE(runtime->TryGetClassFieldDefaultValues("GameScripts", "ProjectScripts", "ProjectScriptProbe", defaultValues));
|
|
ASSERT_EQ(defaultValues.size(), 3u);
|
|
|
|
EXPECT_EQ(defaultValues[0].fieldName, "EnabledOnBoot");
|
|
EXPECT_EQ(defaultValues[0].type, ScriptFieldType::Bool);
|
|
EXPECT_EQ(std::get<bool>(defaultValues[0].value), true);
|
|
|
|
EXPECT_EQ(defaultValues[1].fieldName, "Label");
|
|
EXPECT_EQ(defaultValues[1].type, ScriptFieldType::String);
|
|
EXPECT_EQ(std::get<std::string>(defaultValues[1].value), "ProjectScriptProbe");
|
|
|
|
EXPECT_EQ(defaultValues[2].fieldName, "Speed");
|
|
EXPECT_EQ(defaultValues[2].type, ScriptFieldType::Float);
|
|
EXPECT_FLOAT_EQ(std::get<float>(defaultValues[2].value), 2.5f);
|
|
}
|
|
|
|
} // namespace
|