From e2ee8d5059c90a8d81bc3888413e2468c24242ea Mon Sep 17 00:00:00 2001 From: Michael Aichmueller Date: Thu, 6 Jul 2023 19:50:53 +0200 Subject: [PATCH 1/4] setup cmake files and conan for wasm test build --- CMakeLists.txt | 238 ++++++++++++++++++----------------- cmake/targets/test.cmake | 8 ++ deps/wasm/conanfile_wasm.txt | 3 + 3 files changed, 131 insertions(+), 118 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9cf8de5e4..88350e757 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -70,34 +70,34 @@ add_library(project_warnings INTERFACE) message(STATUS ${CMAKE_SYSTEM_NAME}) -if(WASM) - message(STATUS "Compiling for webassembly using emscripten") - target_compile_definitions(project_options INTERFACE "-DWASM") - target_compile_options(project_options INTERFACE "-fexceptions") -endif() +if (WASM) + message(STATUS "Compiling for webassembly using emscripten") + target_compile_definitions(project_options INTERFACE "-DWASM") + target_compile_options(project_options INTERFACE "-fexceptions") +endif () -if(CMAKE_HOST_WIN32) - message("Compiling with CMAKE_HOST_WIN32") +if (CMAKE_HOST_WIN32) + message("Compiling with CMAKE_HOST_WIN32") - # bigobj is required for windows builds - target_compile_options(project_options INTERFACE "/bigobj") - set_target_properties(project_options PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) -endif() + # bigobj is required for windows builds + target_compile_options(project_options INTERFACE "/bigobj") + set_target_properties(project_options PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) +endif () target_compile_features(project_options INTERFACE ${PROJ_CXX_STD_FEATURE}) -if(ENABLE_PCH) - target_precompile_headers(project_options - INTERFACE - - - - - - - - ) -endif() +if (ENABLE_PCH) + target_precompile_headers(project_options + INTERFACE + + + + + + + + ) +endif () # import utility methods for cmake include(${CMAKE_CONFIG_FOLDER}/settings/Utilities.cmake) @@ -119,6 +119,8 @@ enable_sanitizers(project_options) # allow for static analysis include(${CMAKE_CONFIG_FOLDER}/settings/StaticAnalyzers.cmake) +include(${CMAKE_BINARY_DIR}/conan_paths.cmake) + # glm find_package(glm REQUIRED) @@ -131,107 +133,107 @@ find_package(spdlog REQUIRED) # boost find_package(Boost COMPONENTS Random REQUIRED) -if(NOT WASM) - - include(${CMAKE_BINARY_DIR}/conan_paths.cmake) - - # find the dependencies from conan - set(PYBIND11_FINDPYTHON FALSE) +if (ENABLE_TESTING OR NOT WASM) + # stb + find_package(stb REQUIRED) +endif () - # set(Python_ROOT_DIR /opt/python/$ENV{PYBIN}) - find_package(Python COMPONENTS Interpreter Development.Module REQUIRED) - # pybind11 - find_package(pybind11 REQUIRED) - - # GTest - if(ENABLE_TESTING) +# GTest +if (ENABLE_TESTING) + # gtest find_package(GTest REQUIRED) - endif() +endif () + +if (NOT WASM) + # find the dependencies from conan + set(PYBIND11_FINDPYTHON FALSE) - # stb - find_package(stb REQUIRED) + # set(Python_ROOT_DIR /opt/python/$ENV{PYBIN}) + find_package(Python COMPONENTS Interpreter Development.Module REQUIRED) + # pybind11 + find_package(pybind11 REQUIRED) - # Vulkan - find_package(volk REQUIRED) + # Vulkan + find_package(volk REQUIRED) - # ShaderC for compiling shaders - find_package(shaderc REQUIRED) + # ShaderC for compiling shaders + find_package(shaderc REQUIRED) -endif() +endif () include(${CMAKE_CONFIG_FOLDER}/targets/griddly.cmake) -if(WASM) - include(${CMAKE_CONFIG_FOLDER}/targets/wasm.cmake) -else() - # Compile shaders and copy them into resources directory in build output - if(NOT WASM) - message(STATUS "Compiling shaders...") - - set(ENV{GLSLC_BIN} ${CONAN_SHADERC_ROOT}/bin/glslc) - - if(CMAKE_HOST_WIN32) - execute_process(COMMAND powershell ${CMAKE_CURRENT_SOURCE_DIR}/compile_shaders.bat RESULT_VARIABLE STATUS) - if(STATUS AND NOT STATUS EQUAL 0) - message( FATAL_ERROR "Cannot compile shaders: ${STATUS}") - endif() - else() - execute_process(COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/compile_shaders.sh RESULT_VARIABLE STATUS) - if(STATUS AND NOT STATUS EQUAL 0) - message( FATAL_ERROR "Cannot compile shaders: ${STATUS}") - endif() - endif() - - if(ENABLE_PYTHON_BINDINGS) - message("Configuring Python Bindings.") - include(${CMAKE_CONFIG_FOLDER}/targets/python_griddly.cmake) - endif() - - if(ENABLE_TESTING) - message("Configuring Tests.") - set_property(GLOBAL PROPERTY CTEST_TARGETS_ADDED 1) # prevent CTest from flooding the target space with CI/CD targets - include(CTest) - enable_testing() - include(${CMAKE_CONFIG_FOLDER}/targets/test.cmake) - endif() - endif() - - include(CMakePackageConfigHelpers) - - # Want the python lib to be output in the same directory as the other dll/so - if(CMAKE_HOST_WIN32) - foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES}) - string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG) - set_target_properties(${PYTHON_MODULE} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${BIN_OUTPUT_DIR}) - endforeach(OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES) - endif() - - write_basic_package_version_file( - "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake" - VERSION ${PROJECT_VERSION} - COMPATIBILITY AnyNewerVersion - ) - install(TARGETS project_options EXPORT ${PROJECT_NAME_LOWERCASE}Options) - install(TARGETS ${GRIDDLY_LIB_NAME}_interface ${GRIDDLY_LIB_NAME}_shared ${GRIDDLY_LIB_NAME}_static - EXPORT ${PROJECT_NAME_LOWERCASE}Targets - LIBRARY DESTINATION lib COMPONENT Runtime - ARCHIVE DESTINATION lib COMPONENT Development - RUNTIME DESTINATION bin COMPONENT Runtime - PUBLIC_HEADER DESTINATION include COMPONENT Development - BUNDLE DESTINATION bin COMPONENT Runtime - ) - - include(CMakePackageConfigHelpers) - configure_package_config_file( - "${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME_LOWERCASE}Config.cmake.in" - "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake" - INSTALL_DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE} - ) - install(EXPORT ${PROJECT_NAME_LOWERCASE}Options DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) - install(EXPORT ${PROJECT_NAME_LOWERCASE}Targets DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) - install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake" - "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake" - DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) - install(FILES ${GRIDDLY_HEADERS} DESTINATION include) - install(DIRECTORY ${GRIDDLY_RESOURCE_DIR} DESTINATION resources) -endif() +if (ENABLE_TESTING) + message("Configuring Tests.") + set_property(GLOBAL PROPERTY CTEST_TARGETS_ADDED 1) # prevent CTest from flooding the target space with CI/CD targets + include(CTest) + enable_testing() + include(${CMAKE_CONFIG_FOLDER}/targets/test.cmake) +endif () + +if (WASM) + include(${CMAKE_CONFIG_FOLDER}/targets/wasm.cmake) +else () + # Compile shaders and copy them into resources directory in build output + if (NOT WASM) + message(STATUS "Compiling shaders...") + + set(ENV{GLSLC_BIN} ${CONAN_SHADERC_ROOT}/bin/glslc) + + if (CMAKE_HOST_WIN32) + execute_process(COMMAND powershell ${CMAKE_CURRENT_SOURCE_DIR}/compile_shaders.bat RESULT_VARIABLE STATUS) + if (STATUS AND NOT STATUS EQUAL 0) + message(FATAL_ERROR "Cannot compile shaders: ${STATUS}") + endif () + else () + execute_process(COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/compile_shaders.sh RESULT_VARIABLE STATUS) + if (STATUS AND NOT STATUS EQUAL 0) + message(FATAL_ERROR "Cannot compile shaders: ${STATUS}") + endif () + endif () + + if (ENABLE_PYTHON_BINDINGS) + message("Configuring Python Bindings.") + include(${CMAKE_CONFIG_FOLDER}/targets/python_griddly.cmake) + endif () + endif () + + include(CMakePackageConfigHelpers) + + # Want the python lib to be output in the same directory as the other dll/so + if (CMAKE_HOST_WIN32) + foreach (OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES}) + string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG) + set_target_properties(${PYTHON_MODULE} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${BIN_OUTPUT_DIR}) + endforeach (OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES) + endif () + + write_basic_package_version_file( + "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + install(TARGETS project_options EXPORT ${PROJECT_NAME_LOWERCASE}Options) + install(TARGETS ${GRIDDLY_LIB_NAME}_interface ${GRIDDLY_LIB_NAME}_shared ${GRIDDLY_LIB_NAME}_static + EXPORT ${PROJECT_NAME_LOWERCASE}Targets + LIBRARY DESTINATION lib COMPONENT Runtime + ARCHIVE DESTINATION lib COMPONENT Development + RUNTIME DESTINATION bin COMPONENT Runtime + PUBLIC_HEADER DESTINATION include COMPONENT Development + BUNDLE DESTINATION bin COMPONENT Runtime + ) + + include(CMakePackageConfigHelpers) + configure_package_config_file( + "${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME_LOWERCASE}Config.cmake.in" + "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake" + INSTALL_DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE} + ) + install(EXPORT ${PROJECT_NAME_LOWERCASE}Options DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) + install(EXPORT ${PROJECT_NAME_LOWERCASE}Targets DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) + install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}ConfigVersion.cmake" + "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWERCASE}Config.cmake" + DESTINATION lib/cmake/${PROJECT_NAME_LOWERCASE}) + install(FILES ${GRIDDLY_HEADERS} DESTINATION include) + install(DIRECTORY ${GRIDDLY_RESOURCE_DIR} DESTINATION resources) +endif () diff --git a/cmake/targets/test.cmake b/cmake/targets/test.cmake index 023efb7ae..7f80b7398 100644 --- a/cmake/targets/test.cmake +++ b/cmake/targets/test.cmake @@ -2,6 +2,14 @@ file(GLOB_RECURSE TEST_SOURCES "${GRIDDLY_TEST_SRC_DIR}/*.cpp") +list( + REMOVE_ITEM + TEST_SOURCES + ${GRIDDLY_TEST_SRC_DIR}/Griddly/Core/Observers/SpriteObserverTest.cpp + ${GRIDDLY_TEST_SRC_DIR}/Griddly/Core/Observers/IsometricSpriteObserverTest.cpp + ${GRIDDLY_TEST_SRC_DIR}/Griddly/Core/Observers/BlockObserverTest.cpp +) + add_executable( ${GRIDDLY_TEST_BIN_NAME} ${TEST_SOURCES} diff --git a/deps/wasm/conanfile_wasm.txt b/deps/wasm/conanfile_wasm.txt index f9a71053d..c59a20630 100644 --- a/deps/wasm/conanfile_wasm.txt +++ b/deps/wasm/conanfile_wasm.txt @@ -3,10 +3,13 @@ glm/0.9.9.8 yaml-cpp/0.6.3 spdlog/1.9.2 boost/1.82.0 +gtest/1.11.0 +stb/20200203 [generators] CMakeToolchain CMakeDeps +cmake_paths [options] boost:shared=False From c0b37bcdb20c65a1e3ad49cfad403eb8979ac77a Mon Sep 17 00:00:00 2001 From: Michael Aichmueller Date: Thu, 6 Jul 2023 19:51:14 +0200 Subject: [PATCH 2/4] wasm macros to turn off certain code parts --- tests/src/Griddly/Core/wasm_macro.hpp | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 tests/src/Griddly/Core/wasm_macro.hpp diff --git a/tests/src/Griddly/Core/wasm_macro.hpp b/tests/src/Griddly/Core/wasm_macro.hpp new file mode 100644 index 000000000..2fa9a0158 --- /dev/null +++ b/tests/src/Griddly/Core/wasm_macro.hpp @@ -0,0 +1,20 @@ + +#ifndef GRIDDLY_WASM_MACRO_HPP +#define GRIDDLY_WASM_MACRO_HPP + + +#ifdef WASM +#define GDYFACTORY_ARGS(arg1, arg2) arg1, arg2 +#else +#define GDYFACTORY_ARGS(arg1, arg2) arg1, arg2, ResourceConfig{} +#endif + + +#ifdef WASM +#define WASM_OFF(...) +#else +#define WASM_OFF(...) __VA_ARGS__ +#endif + + +#endif //GRIDDLY_WASM_MACRO_HPP From 3dac6ce91df3cbb5911e887251f3c31e0c6dfe78 Mon Sep 17 00:00:00 2001 From: Michael Aichmueller Date: Thu, 6 Jul 2023 19:51:47 +0200 Subject: [PATCH 3/4] mockgdy macro wrap to adapt for wasm usage --- .../Mocks/Griddly/Core/GDY/MockGDYFactory.hpp | 61 ++++++++++--------- 1 file changed, 33 insertions(+), 28 deletions(-) diff --git a/tests/src/Mocks/Griddly/Core/GDY/MockGDYFactory.hpp b/tests/src/Mocks/Griddly/Core/GDY/MockGDYFactory.hpp index b24b2b7a4..b55a543a9 100644 --- a/tests/src/Mocks/Griddly/Core/GDY/MockGDYFactory.hpp +++ b/tests/src/Mocks/Griddly/Core/GDY/MockGDYFactory.hpp @@ -2,35 +2,40 @@ #include "Griddly/Core/GDY/GDYFactory.hpp" #include "gmock/gmock.h" +#include "Griddly/Core/wasm_macro.hpp" namespace griddly { -class MockGDYFactory : public GDYFactory { - public: - MockGDYFactory() - : GDYFactory(nullptr, nullptr, {}) {} - - MOCK_METHOD(std::shared_ptr, getTerminationGenerator, (), (const)); - MOCK_METHOD(std::shared_ptr, getLevelGenerator, (uint32_t), (const)); - MOCK_METHOD(std::shared_ptr, getObjectGenerator, (), (const)); - MOCK_METHOD((std::unordered_map), getSpriteObserverDefinitions, (), (const)); - MOCK_METHOD((std::unordered_map), getBlockObserverDefinitions, (), (const)); - - MOCK_METHOD((std::map&), getGlobalVariableDefinitions, (), (const)); - - MOCK_METHOD(std::shared_ptr, createTerminationHandler, (std::shared_ptr grid, std::vector> players), (const)); - MOCK_METHOD(std::shared_ptr, createObserver, (std::shared_ptr grid, std::string observerName, uint32_t playerCount, uint32_t playerId), ()); - - MOCK_METHOD(glm::ivec2, getTileSize, (), (const)); - MOCK_METHOD(std::string, getName, (), (const)); - MOCK_METHOD(uint32_t, getNumLevels, (), (const)); - - MOCK_METHOD(uint32_t, getActionDefinitionCount, (), (const)); - MOCK_METHOD((std::unordered_map), getActionInputsDefinitions, (), (const)); - - MOCK_METHOD(std::string, getActionName, (uint32_t idx), (const)); - - MOCK_METHOD(uint32_t, getPlayerCount, (), (const)); - MOCK_METHOD(DefaultObserverConfig, getPlayerObserverDefinition, (), (const)); -}; + class MockGDYFactory : public GDYFactory { + public: + MockGDYFactory() + : GDYFactory(GDYFACTORY_ARGS(nullptr, nullptr)) {} + + MOCK_METHOD(std::shared_ptr, getTerminationGenerator, (), (const)); + MOCK_METHOD(std::shared_ptr, getLevelGenerator, (uint32_t), (const)); + MOCK_METHOD(std::shared_ptr, getObjectGenerator, (), (const)); + WASM_OFF( + MOCK_METHOD((std::unordered_map), getSpriteObserverDefinitions, (), (const)); + MOCK_METHOD((std::unordered_map), getBlockObserverDefinitions, (), (const)); + ) + MOCK_METHOD((std::map & ), getGlobalVariableDefinitions, (), (const)); + + MOCK_METHOD(std::shared_ptr, createTerminationHandler, + (std::shared_ptr grid, std::vector> players), (const)); + MOCK_METHOD(std::shared_ptr, createObserver, + (std::shared_ptr grid, std::string observerName, uint32_t playerCount, uint32_t playerId), + ()); + + MOCK_METHOD(glm::ivec2, getTileSize, (), (const)); + MOCK_METHOD(std::string, getName, (), (const)); + MOCK_METHOD(uint32_t, getNumLevels, (), (const)); + + MOCK_METHOD(uint32_t, getActionDefinitionCount, (), (const)); + MOCK_METHOD((std::unordered_map), getActionInputsDefinitions, (), (const)); + + MOCK_METHOD(std::string, getActionName, (uint32_t idx), (const)); + + MOCK_METHOD(uint32_t, getPlayerCount, (), (const)); + MOCK_METHOD(DefaultObserverConfig, getPlayerObserverDefinition, (), (const)); + }; } // namespace griddly \ No newline at end of file From 4a8d1d52d93da4dbed771571b6c542c176ad437c Mon Sep 17 00:00:00 2001 From: Michael Aichmueller Date: Thu, 6 Jul 2023 19:52:12 +0200 Subject: [PATCH 4/4] refactor gdyfactory test to use gtest fixture and run with wasm --- tests/src/Griddly/Core/GDY/GDYFactoryTest.cpp | 2066 ++++++++--------- 1 file changed, 1032 insertions(+), 1034 deletions(-) diff --git a/tests/src/Griddly/Core/GDY/GDYFactoryTest.cpp b/tests/src/Griddly/Core/GDY/GDYFactoryTest.cpp index 5095c95d5..cdd8da63b 100644 --- a/tests/src/Griddly/Core/GDY/GDYFactoryTest.cpp +++ b/tests/src/Griddly/Core/GDY/GDYFactoryTest.cpp @@ -7,6 +7,8 @@ #include "Griddly/Core/GDY/Actions/Action.hpp" #include "Griddly/Core/GDY/GDYFactory.hpp" #include "Griddly/Core/TestUtils/common.hpp" +#include "Griddly/Core/wasm_macro.hpp" + #include "Mocks//Griddly/Core/LevelGenerators/MockLevelGenerator.hpp" #include "Mocks/Griddly/Core/GDY/MockTerminationGenerator.hpp" #include "Mocks/Griddly/Core/GDY/Objects/MockObject.hpp" @@ -17,6 +19,7 @@ #define _Y(X) YAML::Node(X) + using ::testing::_; using ::testing::ElementsAre; using ::testing::ElementsAreArray; @@ -29,47 +32,117 @@ using ::testing::UnorderedElementsAre; namespace griddly { -YAML::Node loadAndGetNode(std::string filename, std::string nodeName) { - auto node = YAML::LoadFile(filename); - return node[nodeName]; -} -YAML::Node loadFromStringAndGetNode(std::string yamlString, std::string nodeName) { - auto node = YAML::Load(yamlString.c_str()); - return node[nodeName]; -} + YAML::Node loadAndGetNode(std::string filename, std::string nodeName) { + auto node = YAML::LoadFile(filename); + return node[nodeName]; + } + + YAML::Node loadFromStringAndGetNode(std::string yamlString, std::string nodeName) { + auto node = YAML::Load(yamlString.c_str()); + return node[nodeName]; + } + + class GDYFactoryTestF : public ::testing::Test { + public: + GDYFactoryTestF() = default; + + void SetUp() override { + mockObjectGeneratorPtr = std::make_shared(); + mockTerminationGeneratorPtr = std::make_shared(); + + gdyFactory = std::make_shared( + GDYFACTORY_ARGS(mockObjectGeneratorPtr, mockTerminationGeneratorPtr)); + } + + + void + expectOpposingDefinitionNOP(ActionBehaviourType behaviourType, uint32_t behaviourIdx, + std::string sourceObjectName, + std::string destinationObjectName) { + ActionBehaviourDefinition expectedNOPDefinition = GDYFactory::makeBehaviourDefinition( + behaviourType == ActionBehaviourType::DESTINATION ? ActionBehaviourType::SOURCE + : ActionBehaviourType::DESTINATION, + behaviourIdx, + behaviourType == ActionBehaviourType::DESTINATION ? sourceObjectName : destinationObjectName, + behaviourType == ActionBehaviourType::SOURCE ? sourceObjectName : destinationObjectName, + "action", + "nop", + {}, + {}, + {}); + + auto objectName = behaviourType == ActionBehaviourType::SOURCE ? destinationObjectName : sourceObjectName; + + EXPECT_CALL(*mockObjectGeneratorPtr, + defineActionBehaviour(Eq(objectName), + ActionBehaviourDefinitionEqMatcher(expectedNOPDefinition))) + .Times(1); + } + + void testBehaviourDefinition(std::string yamlString, ActionBehaviourDefinition expectedBehaviourDefinition, + bool expectNOP) { + + + auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + + gdyFactory->loadObjects(objectsNode); -TEST(GDYFactoryTest, loadEnvironment) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto environmentNode = loadAndGetNode("tests/resources/loadEnvironment.yaml", "Environment"); + auto actionsNode = loadFromStringAndGetNode(yamlString, "Actions"); - std::string objectName = "object"; + auto objectName = expectedBehaviourDefinition.behaviourType == ActionBehaviourType::SOURCE + ? expectedBehaviourDefinition.sourceObjectName + : expectedBehaviourDefinition.destinationObjectName; - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('W'))) - .WillRepeatedly(ReturnRef(objectName)); + EXPECT_CALL(*mockObjectGeneratorPtr, + defineActionBehaviour(Eq(objectName), ActionBehaviourDefinitionEqMatcher( + expectedBehaviourDefinition))) + .Times(1); - gdyFactory->loadEnvironment(environmentNode); + if (expectNOP) { + expectOpposingDefinitionNOP(expectedBehaviourDefinition.behaviourType, + expectedBehaviourDefinition.behaviourIdx, + expectedBehaviourDefinition.sourceObjectName, + expectedBehaviourDefinition.destinationObjectName); + } - ASSERT_EQ(gdyFactory->getName(), "Test Environment"); - ASSERT_EQ(gdyFactory->getLevelCount(), 1); + gdyFactory->loadActions(actionsNode); - auto globalVariableDefinitions = gdyFactory->getGlobalVariableDefinitions(); - ASSERT_EQ(globalVariableDefinitions["global_variable1"].initialValue, 50); - ASSERT_EQ(globalVariableDefinitions["global_variable1"].perPlayer, false); - ASSERT_EQ(globalVariableDefinitions["global_variable2"].initialValue, 0); - ASSERT_EQ(globalVariableDefinitions["global_variable2"].perPlayer, true); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + protected: + std::shared_ptr mockObjectGeneratorPtr; + std::shared_ptr mockTerminationGeneratorPtr; + std::shared_ptr gdyFactory; + }; -TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_playerId) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + + TEST_F(GDYFactoryTestF, loadEnvironment) { + auto environmentNode = loadAndGetNode("tests/resources/loadEnvironment.yaml", "Environment"); + + std::string objectName = "object"; + + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('W'))) + .WillRepeatedly(ReturnRef(objectName)); + + gdyFactory->loadEnvironment(environmentNode); + + ASSERT_EQ(gdyFactory->getName(), "Test Environment"); + ASSERT_EQ(gdyFactory->getLevelCount(), 1); + + auto globalVariableDefinitions = gdyFactory->getGlobalVariableDefinitions(); + ASSERT_EQ(globalVariableDefinitions["global_variable1"].initialValue, 50); + ASSERT_EQ(globalVariableDefinitions["global_variable1"].perPlayer, false); + ASSERT_EQ(globalVariableDefinitions["global_variable2"].initialValue, 0); + ASSERT_EQ(globalVariableDefinitions["global_variable2"].perPlayer, true); + + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } + + TEST_F(GDYFactoryTestF, loadEnvironment_VectorObserverConfig_playerId) { + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -78,28 +151,26 @@ TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_playerId) { IncludePlayerId: True )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + + gdyFactory->loadEnvironment(environmentNode); - gdyFactory->loadEnvironment(environmentNode); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + auto config = gdyFactory->generateConfigForObserver("Vector"); - auto config = gdyFactory->generateConfigForObserver("Vector"); + ASSERT_EQ(config.includePlayerId, true); + ASSERT_EQ(config.includeRotation, false); + ASSERT_EQ(config.includeVariables, false); - ASSERT_EQ(config.includePlayerId, true); - ASSERT_EQ(config.includeRotation, false); - ASSERT_EQ(config.includeVariables, false); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + TEST_F(GDYFactoryTestF, loadEnvironment_VectorObserverConfig_variables) { -TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_variables) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -108,28 +179,26 @@ TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_variables) { IncludeVariables: True )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - auto config = gdyFactory->generateConfigForObserver("Vector"); + auto config = gdyFactory->generateConfigForObserver("Vector"); - ASSERT_EQ(config.includePlayerId, false); - ASSERT_EQ(config.includeRotation, false); - ASSERT_EQ(config.includeVariables, true); + ASSERT_EQ(config.includePlayerId, false); + ASSERT_EQ(config.includeRotation, false); + ASSERT_EQ(config.includeVariables, true); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_rotation) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_VectorObserverConfig_rotation) { + + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -138,28 +207,25 @@ TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_rotation) { IncludeRotation: True )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - auto config = gdyFactory->generateConfigForObserver("Vector"); + auto config = gdyFactory->generateConfigForObserver("Vector"); - ASSERT_EQ(config.includePlayerId, false); - ASSERT_EQ(config.includeRotation, true); - ASSERT_EQ(config.includeVariables, false); + ASSERT_EQ(config.includePlayerId, false); + ASSERT_EQ(config.includeRotation, true); + ASSERT_EQ(config.includeVariables, false); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_playerId_rotation_variables) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_VectorObserverConfig_playerId_rotation_variables) { + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -170,54 +236,49 @@ TEST(GDYFactoryTest, loadEnvironment_VectorObserverConfig_playerId_rotation_vari IncludeRotation: True )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + + gdyFactory->loadEnvironment(environmentNode); - gdyFactory->loadEnvironment(environmentNode); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + auto config = gdyFactory->generateConfigForObserver("Vector"); - auto config = gdyFactory->generateConfigForObserver("Vector"); + ASSERT_EQ(config.includePlayerId, true); + ASSERT_EQ(config.includeRotation, true); + ASSERT_EQ(config.includeVariables, true); - ASSERT_EQ(config.includePlayerId, true); - ASSERT_EQ(config.includeRotation, true); - ASSERT_EQ(config.includeVariables, true); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + TEST_F(GDYFactoryTestF, loadEnvironment_Observer) { + auto environmentNode = loadAndGetNode("tests/resources/loadEnvironmentObserver.yaml", "Environment"); -TEST(GDYFactoryTest, loadEnvironment_Observer) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto environmentNode = loadAndGetNode("tests/resources/loadEnvironmentObserver.yaml", "Environment"); + EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) + .Times(1); - EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) - .Times(1); + gdyFactory->loadEnvironment(environmentNode); - gdyFactory->loadEnvironment(environmentNode); + ASSERT_EQ(gdyFactory->getName(), "Test Environment"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - ASSERT_EQ(gdyFactory->getName(), "Test Environment"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + ASSERT_EQ(observerConfig.overrideGridHeight, 1); + ASSERT_EQ(observerConfig.overrideGridWidth, 2); + ASSERT_EQ(observerConfig.gridXOffset, 3); + ASSERT_EQ(observerConfig.gridYOffset, 4); + ASSERT_TRUE(observerConfig.trackAvatar); - ASSERT_EQ(observerConfig.overrideGridHeight, 1); - ASSERT_EQ(observerConfig.overrideGridWidth, 2); - ASSERT_EQ(observerConfig.gridXOffset, 3); - ASSERT_EQ(observerConfig.gridYOffset, 4); - ASSERT_TRUE(observerConfig.trackAvatar); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + TEST_F(GDYFactoryTestF, loadEnvironment_ObserverShaderOptions) { -TEST(GDYFactoryTest, loadEnvironment_ObserverShaderOptions) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + auto yamlString = R"( Environment: Name: Test Environment TileSize: 16 @@ -242,29 +303,29 @@ TEST(GDYFactoryTest, loadEnvironment_ObserverShaderOptions) { )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); + WASM_OFF( + auto blockObserverConfig = gdyFactory->generateConfigForObserver("Block"); + ASSERT_EQ(blockObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::GRAYSCALE_INVISIBLE); - auto blockObserverConfig = gdyFactory->generateConfigForObserver("Block"); - ASSERT_EQ(blockObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::GRAYSCALE_INVISIBLE); + auto spriteObserverConfig = gdyFactory->generateConfigForObserver("Sprite"); + ASSERT_EQ(spriteObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::DARKEN_INVISIBLE); - auto spriteObserverConfig = gdyFactory->generateConfigForObserver("Sprite"); - ASSERT_EQ(spriteObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::DARKEN_INVISIBLE); + auto isometricObserverConfig = gdyFactory->generateConfigForObserver("Isometric"); + ASSERT_EQ(isometricObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::REMOVE_INVISIBLE); - auto isometricObserverConfig = gdyFactory->generateConfigForObserver("Isometric"); - ASSERT_EQ(isometricObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::REMOVE_INVISIBLE); - - auto blockHightlightedObserverConfig = gdyFactory->generateConfigForObserver("BlockHighlighted"); - ASSERT_EQ(blockHightlightedObserverConfig.globalObserverAvatarMode, GlobalObserverAvatarMode::HIGHLIGHT_VISIBLE); - ASSERT_EQ(blockHightlightedObserverConfig.globalObserverAvatarHighlightColor, glm::vec3(0.3, 0.2, 0.1)); -} + auto blockHightlightedObserverConfig = gdyFactory->generateConfigForObserver( + "BlockHighlighted"); + ASSERT_EQ(blockHightlightedObserverConfig.globalObserverAvatarMode, + GlobalObserverAvatarMode::HIGHLIGHT_VISIBLE); + ASSERT_EQ(blockHightlightedObserverConfig.globalObserverAvatarHighlightColor, glm::vec3(0.3, 0.2, 0.1)); + ) + } -TEST(GDYFactoryTest, loadEnvironment_NamedObservers) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_NamedObservers) { + auto yamlString = R"( Environment: Name: Test Environment TileSize: 16 @@ -294,46 +355,48 @@ TEST(GDYFactoryTest, loadEnvironment_NamedObservers) { )"; - EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) - .Times(1); - - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - - gdyFactory->loadEnvironment(environmentNode); - - auto observerConfig = gdyFactory->getDefaultObserverConfig(); - - ASSERT_EQ(observerConfig.overrideGridHeight, 1); - ASSERT_EQ(observerConfig.overrideGridWidth, 2); - ASSERT_EQ(observerConfig.gridXOffset, 3); - ASSERT_EQ(observerConfig.gridYOffset, 4); - ASSERT_TRUE(observerConfig.trackAvatar); - ASSERT_FALSE(observerConfig.rotateAvatarImage); - ASSERT_TRUE(observerConfig.rotateWithAvatar); - - auto defaultVectorObserverConfig = gdyFactory->generateConfigForObserver("TestVectorObserver"); - ASSERT_EQ(defaultVectorObserverConfig.overrideGridHeight, 1); - ASSERT_EQ(defaultVectorObserverConfig.overrideGridWidth, 2); - ASSERT_EQ(defaultVectorObserverConfig.gridXOffset, 3); - ASSERT_EQ(defaultVectorObserverConfig.gridYOffset, 4); - ASSERT_FALSE(defaultVectorObserverConfig.trackAvatar); - ASSERT_TRUE(defaultVectorObserverConfig.includePlayerId); - - auto defaultBlockObserverConfig = gdyFactory->generateConfigForObserver("TestSprite2DObserver"); - ASSERT_EQ(defaultBlockObserverConfig.overrideGridHeight, 10); - ASSERT_EQ(defaultBlockObserverConfig.overrideGridWidth, 10); - ASSERT_EQ(defaultBlockObserverConfig.gridXOffset, 0); - ASSERT_EQ(defaultBlockObserverConfig.gridYOffset, 0); - ASSERT_TRUE(defaultBlockObserverConfig.trackAvatar); - ASSERT_FALSE(defaultBlockObserverConfig.rotateWithAvatar); - ASSERT_TRUE(defaultBlockObserverConfig.rotateAvatarImage); -} - -TEST(GDYFactoryTest, loadEnvironment_EntityObserverConfigs) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) + .Times(1); + + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + + gdyFactory->loadEnvironment(environmentNode); + + auto observerConfig = gdyFactory->getDefaultObserverConfig(); + + ASSERT_EQ(observerConfig.overrideGridHeight, 1); + ASSERT_EQ(observerConfig.overrideGridWidth, 2); + ASSERT_EQ(observerConfig.gridXOffset, 3); + ASSERT_EQ(observerConfig.gridYOffset, 4); + ASSERT_TRUE(observerConfig.trackAvatar); + ASSERT_FALSE(observerConfig.rotateAvatarImage); + ASSERT_TRUE(observerConfig.rotateWithAvatar); + + auto defaultVectorObserverConfig = gdyFactory->generateConfigForObserver( + "TestVectorObserver"); + ASSERT_EQ(defaultVectorObserverConfig.overrideGridHeight, 1); + ASSERT_EQ(defaultVectorObserverConfig.overrideGridWidth, 2); + ASSERT_EQ(defaultVectorObserverConfig.gridXOffset, 3); + ASSERT_EQ(defaultVectorObserverConfig.gridYOffset, 4); + ASSERT_FALSE(defaultVectorObserverConfig.trackAvatar); + ASSERT_TRUE(defaultVectorObserverConfig.includePlayerId); + + WASM_OFF( + auto defaultBlockObserverConfig = gdyFactory->generateConfigForObserver( + "TestSprite2DObserver"); + ASSERT_EQ(defaultBlockObserverConfig.overrideGridHeight, 10); + ASSERT_EQ(defaultBlockObserverConfig.overrideGridWidth, 10); + ASSERT_EQ(defaultBlockObserverConfig.gridXOffset, 0); + ASSERT_EQ(defaultBlockObserverConfig.gridYOffset, 0); + ASSERT_TRUE(defaultBlockObserverConfig.trackAvatar); + ASSERT_FALSE(defaultBlockObserverConfig.rotateWithAvatar); + ASSERT_TRUE(defaultBlockObserverConfig.rotateAvatarImage); + ) + } + + TEST_F(GDYFactoryTestF, loadEnvironment_EntityObserverConfigs) { + + auto yamlString = R"( Environment: Name: Test Environment TileSize: 16 @@ -371,37 +434,35 @@ TEST(GDYFactoryTest, loadEnvironment_EntityObserverConfigs) { )"; - EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) - .Times(1); - - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - auto actionNode = loadFromStringAndGetNode(yamlString, "Actions"); - auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); - - gdyFactory->loadObjects(objectsNode); - gdyFactory->loadActions(actionNode); - gdyFactory->loadEnvironment(environmentNode); - - auto entityObserverConfig = gdyFactory->generateConfigForObserver("TestEntityObserver"); - ASSERT_EQ(entityObserverConfig.overrideGridHeight, 1); - ASSERT_EQ(entityObserverConfig.overrideGridWidth, 2); - ASSERT_EQ(entityObserverConfig.gridXOffset, 3); - ASSERT_EQ(entityObserverConfig.gridYOffset, 4); - ASSERT_TRUE(entityObserverConfig.trackAvatar); - ASSERT_THAT(entityObserverConfig.includePlayerId, UnorderedElementsAre("entity1", "entity2")); - ASSERT_THAT(entityObserverConfig.includeRotation, UnorderedElementsAre("entity1")); - ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity1"][0], "variable11"); - ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity1"][1], "variable12"); - ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity2"][0], "variable21"); - ASSERT_EQ(entityObserverConfig.actionInputsDefinitions.size(), 1); - ASSERT_THAT(entityObserverConfig.objectNames, UnorderedElementsAre("entity1", "entity2")); -} - -TEST(GDYFactoryTest, loadEnvironment_BlockObserverConfig) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + EXPECT_CALL(*mockObjectGeneratorPtr, setAvatarObject(Eq("avatar"))) + .Times(1); + + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto actionNode = loadFromStringAndGetNode(yamlString, "Actions"); + auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + + gdyFactory->loadObjects(objectsNode); + gdyFactory->loadActions(actionNode); + gdyFactory->loadEnvironment(environmentNode); + + auto entityObserverConfig = gdyFactory->generateConfigForObserver( + "TestEntityObserver"); + ASSERT_EQ(entityObserverConfig.overrideGridHeight, 1); + ASSERT_EQ(entityObserverConfig.overrideGridWidth, 2); + ASSERT_EQ(entityObserverConfig.gridXOffset, 3); + ASSERT_EQ(entityObserverConfig.gridYOffset, 4); + ASSERT_TRUE(entityObserverConfig.trackAvatar); + ASSERT_THAT(entityObserverConfig.includePlayerId, UnorderedElementsAre("entity1", "entity2")); + ASSERT_THAT(entityObserverConfig.includeRotation, UnorderedElementsAre("entity1")); + ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity1"][0], "variable11"); + ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity1"][1], "variable12"); + ASSERT_EQ(entityObserverConfig.entityVariableMapping["entity2"][0], "variable21"); + ASSERT_EQ(entityObserverConfig.actionInputsDefinitions.size(), 1); + ASSERT_THAT(entityObserverConfig.objectNames, UnorderedElementsAre("entity1", "entity2")); + } + + TEST_F(GDYFactoryTestF, loadEnvironment_BlockObserverConfig) { + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -412,29 +473,28 @@ TEST(GDYFactoryTest, loadEnvironment_BlockObserverConfig) { )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); + WASM_OFF( + auto config = gdyFactory->generateConfigForObserver("Block2D"); - auto config = gdyFactory->generateConfigForObserver("Block2D"); + ASSERT_EQ(config.tileSize, glm::ivec2(24, 24)); + ASSERT_EQ(config.backgroundColor, glm::vec3(0.3, 0.3, 0.3)); + ASSERT_EQ(config.gridXOffset, 0); + ASSERT_EQ(config.gridYOffset, 0); - ASSERT_EQ(config.tileSize, glm::ivec2(24, 24)); - ASSERT_EQ(config.backgroundColor, glm::vec3(0.3, 0.3, 0.3)); - ASSERT_EQ(config.gridXOffset, 0); - ASSERT_EQ(config.gridYOffset, 0); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + ) + } - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + TEST_F(GDYFactoryTestF, loadEnvironment_SpriteObserverConfig) { -TEST(GDYFactoryTest, loadEnvironment_SpriteObserverConfig) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -444,31 +504,30 @@ TEST(GDYFactoryTest, loadEnvironment_SpriteObserverConfig) { BackgroundTile: oryx/oryx_fantasy/floor2-2.png )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - auto config = gdyFactory->generateConfigForObserver("Sprite2D"); + WASM_OFF( + auto config = gdyFactory->generateConfigForObserver("Sprite2D"); - ASSERT_EQ(config.tileSize, glm::ivec2(24, 24)); - ASSERT_EQ(config.gridXOffset, 0); - ASSERT_EQ(config.gridYOffset, 0); + ASSERT_EQ(config.tileSize, glm::ivec2(24, 24)); + ASSERT_EQ(config.gridXOffset, 0); + ASSERT_EQ(config.gridYOffset, 0); - auto backgroundTile = config.spriteDefinitions["_background_"]; - ASSERT_EQ(backgroundTile.images[0], "oryx/oryx_fantasy/floor2-2.png"); + auto backgroundTile = config.spriteDefinitions["_background_"]; + ASSERT_EQ(backgroundTile.images[0], "oryx/oryx_fantasy/floor2-2.png"); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + ) + } -TEST(GDYFactoryTest, loadEnvironment_IsometricSpriteObserverConfig) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_IsometricSpriteObserverConfig) { + auto yamlString = R"( Environment: Name: Test Description: Test Description @@ -480,56 +539,54 @@ TEST(GDYFactoryTest, loadEnvironment_IsometricSpriteObserverConfig) { BackgroundTile: oryx/oryx_iso_dungeon/grass.png )"; - auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); + auto environmentNode = loadFromStringAndGetNode(yamlString, "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - auto config = gdyFactory->generateConfigForObserver("Isometric"); + WASM_OFF( + auto config = gdyFactory->generateConfigForObserver("Isometric"); - ASSERT_EQ(config.tileSize, glm::ivec2(32, 48)); - ASSERT_EQ(config.isoTileDepth, 4); - ASSERT_EQ(config.isoTileHeight, 16); - ASSERT_EQ(config.gridXOffset, 0); - ASSERT_EQ(config.gridYOffset, 0); + ASSERT_EQ(config.tileSize, glm::ivec2(32, 48)); + ASSERT_EQ(config.isoTileDepth, 4); + ASSERT_EQ(config.isoTileHeight, 16); + ASSERT_EQ(config.gridXOffset, 0); + ASSERT_EQ(config.gridYOffset, 0); - auto backgroundTile = config.spriteDefinitions["_iso_background_"]; - ASSERT_EQ(backgroundTile.images[0], "oryx/oryx_iso_dungeon/grass.png"); + auto backgroundTile = config.spriteDefinitions["_iso_background_"]; + ASSERT_EQ(backgroundTile.images[0], "oryx/oryx_iso_dungeon/grass.png"); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + ) + } -TEST(GDYFactoryTest, loadEnvironment_ObserverNoAvatar) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto environmentNode = loadAndGetNode("tests/resources/loadEnvironmentObserverNoAvatar.yaml", "Environment"); + TEST_F(GDYFactoryTestF, loadEnvironment_ObserverNoAvatar) { + auto environmentNode = loadAndGetNode("tests/resources/loadEnvironmentObserverNoAvatar.yaml", + "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - ASSERT_EQ(gdyFactory->getName(), "Test Environment"); - ASSERT_EQ(gdyFactory->getLevelCount(), 0); + ASSERT_EQ(gdyFactory->getName(), "Test Environment"); + ASSERT_EQ(gdyFactory->getLevelCount(), 0); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - // the AvatarObject: avatarName is missing so we default to selective control + no avatar tracking - ASSERT_EQ(observerConfig.overrideGridHeight, 0); - ASSERT_EQ(observerConfig.overrideGridWidth, 0); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_FALSE(observerConfig.trackAvatar); + // the AvatarObject: avatarName is missing so we default to selective control + no avatar tracking + ASSERT_EQ(observerConfig.overrideGridHeight, 0); + ASSERT_EQ(observerConfig.overrideGridWidth, 0); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_FALSE(observerConfig.trackAvatar); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadEnvironment_PlayerHighlight) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_PlayerHighlight) { + auto yamlString = R"( Environment: Name: Test Player: @@ -541,24 +598,22 @@ TEST(GDYFactoryTest, loadEnvironment_PlayerHighlight) { Width: 9 )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_TRUE(observerConfig.highlightPlayers); - ASSERT_TRUE(observerConfig.trackAvatar); -} + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_TRUE(observerConfig.highlightPlayers); + ASSERT_TRUE(observerConfig.trackAvatar); + } -TEST(GDYFactoryTest, loadEnvironment_loadDefaults01) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_loadDefaults01) { + auto yamlString = R"( Environment: Name: Test Player: @@ -580,58 +635,58 @@ TEST(GDYFactoryTest, loadEnvironment_loadDefaults01) { - Image: iso_test.png )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - auto objectsNode = loadFromStringAndGetNode(std::string(yamlString), "Objects"); - - gdyFactory->loadObjects(objectsNode); - gdyFactory->loadEnvironment(environmentNode); - - auto observerConfig = gdyFactory->getDefaultObserverConfig(); - - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_TRUE(observerConfig.highlightPlayers); - ASSERT_TRUE(observerConfig.trackAvatar); - - auto defaultVectorObserverConfig = gdyFactory->generateConfigForObserver("Vector"); - ASSERT_EQ(defaultVectorObserverConfig.overrideGridHeight, 9); - ASSERT_EQ(defaultVectorObserverConfig.overrideGridWidth, 9); - ASSERT_EQ(defaultVectorObserverConfig.gridXOffset, 0); - ASSERT_EQ(defaultVectorObserverConfig.gridYOffset, 0); - ASSERT_TRUE(defaultVectorObserverConfig.trackAvatar); - ASSERT_FALSE(defaultVectorObserverConfig.rotateWithAvatar); - - auto defaultSpriteObserverConfig = gdyFactory->generateConfigForObserver("Sprite2D"); - ASSERT_EQ(defaultSpriteObserverConfig.overrideGridHeight, 9); - ASSERT_EQ(defaultSpriteObserverConfig.overrideGridWidth, 9); - ASSERT_EQ(defaultSpriteObserverConfig.gridXOffset, 0); - ASSERT_EQ(defaultSpriteObserverConfig.gridYOffset, 0); - ASSERT_TRUE(defaultSpriteObserverConfig.trackAvatar); - ASSERT_FALSE(defaultSpriteObserverConfig.rotateWithAvatar); - - auto defaultBlockObserverConfig = gdyFactory->generateConfigForObserver("Block2D"); - ASSERT_EQ(defaultBlockObserverConfig.overrideGridHeight, 9); - ASSERT_EQ(defaultBlockObserverConfig.overrideGridWidth, 9); - ASSERT_EQ(defaultBlockObserverConfig.gridXOffset, 0); - ASSERT_EQ(defaultBlockObserverConfig.gridYOffset, 0); - ASSERT_TRUE(defaultBlockObserverConfig.trackAvatar); - ASSERT_FALSE(defaultBlockObserverConfig.rotateWithAvatar); - - auto defaultASCIIObserverConfig = gdyFactory->generateConfigForObserver("ASCII"); - ASSERT_EQ(defaultASCIIObserverConfig.overrideGridHeight, 9); - ASSERT_EQ(defaultASCIIObserverConfig.overrideGridWidth, 9); - ASSERT_EQ(defaultASCIIObserverConfig.gridXOffset, 0); - ASSERT_EQ(defaultASCIIObserverConfig.gridYOffset, 0); - ASSERT_TRUE(defaultASCIIObserverConfig.trackAvatar); - ASSERT_FALSE(defaultASCIIObserverConfig.rotateWithAvatar); -} - -TEST(GDYFactoryTest, loadEnvironment_PlayerNoHighlight) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto objectsNode = loadFromStringAndGetNode(std::string(yamlString), "Objects"); + + gdyFactory->loadObjects(objectsNode); + gdyFactory->loadEnvironment(environmentNode); + + auto observerConfig = gdyFactory->getDefaultObserverConfig(); + + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_TRUE(observerConfig.highlightPlayers); + ASSERT_TRUE(observerConfig.trackAvatar); + + auto defaultVectorObserverConfig = gdyFactory->generateConfigForObserver("Vector"); + ASSERT_EQ(defaultVectorObserverConfig.overrideGridHeight, 9); + ASSERT_EQ(defaultVectorObserverConfig.overrideGridWidth, 9); + ASSERT_EQ(defaultVectorObserverConfig.gridXOffset, 0); + ASSERT_EQ(defaultVectorObserverConfig.gridYOffset, 0); + ASSERT_TRUE(defaultVectorObserverConfig.trackAvatar); + ASSERT_FALSE(defaultVectorObserverConfig.rotateWithAvatar); + + WASM_OFF( + auto defaultSpriteObserverConfig = gdyFactory->generateConfigForObserver( + "Sprite2D"); + ASSERT_EQ(defaultSpriteObserverConfig.overrideGridHeight, 9); + ASSERT_EQ(defaultSpriteObserverConfig.overrideGridWidth, 9); + ASSERT_EQ(defaultSpriteObserverConfig.gridXOffset, 0); + ASSERT_EQ(defaultSpriteObserverConfig.gridYOffset, 0); + ASSERT_TRUE(defaultSpriteObserverConfig.trackAvatar); + ASSERT_FALSE(defaultSpriteObserverConfig.rotateWithAvatar); + + auto defaultBlockObserverConfig = gdyFactory->generateConfigForObserver("Block2D"); + ASSERT_EQ(defaultBlockObserverConfig.overrideGridHeight, 9); + ASSERT_EQ(defaultBlockObserverConfig.overrideGridWidth, 9); + ASSERT_EQ(defaultBlockObserverConfig.gridXOffset, 0); + ASSERT_EQ(defaultBlockObserverConfig.gridYOffset, 0); + ASSERT_TRUE(defaultBlockObserverConfig.trackAvatar); + ASSERT_FALSE(defaultBlockObserverConfig.rotateWithAvatar); + ) + auto defaultASCIIObserverConfig = gdyFactory->generateConfigForObserver("ASCII"); + ASSERT_EQ(defaultASCIIObserverConfig.overrideGridHeight, 9); + ASSERT_EQ(defaultASCIIObserverConfig.overrideGridWidth, 9); + ASSERT_EQ(defaultASCIIObserverConfig.gridXOffset, 0); + ASSERT_EQ(defaultASCIIObserverConfig.gridYOffset, 0); + ASSERT_TRUE(defaultASCIIObserverConfig.trackAvatar); + ASSERT_FALSE(defaultASCIIObserverConfig.rotateWithAvatar); + } + + TEST_F(GDYFactoryTestF, loadEnvironment_PlayerNoHighlight) { + auto yamlString = R"( Environment: Name: Test Player: @@ -642,26 +697,24 @@ TEST(GDYFactoryTest, loadEnvironment_PlayerNoHighlight) { Width: 9 )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_FALSE(observerConfig.highlightPlayers); - ASSERT_TRUE(observerConfig.trackAvatar); - ASSERT_FALSE(observerConfig.rotateWithAvatar); - ASSERT_TRUE(observerConfig.rotateAvatarImage); -} + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_FALSE(observerConfig.highlightPlayers); + ASSERT_TRUE(observerConfig.trackAvatar); + ASSERT_FALSE(observerConfig.rotateWithAvatar); + ASSERT_TRUE(observerConfig.rotateAvatarImage); + } -TEST(GDYFactoryTest, loadEnvironment_RotateAvatar) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_RotateAvatar) { + auto yamlString = R"( Environment: Name: Test Player: @@ -672,26 +725,24 @@ TEST(GDYFactoryTest, loadEnvironment_RotateAvatar) { Width: 9 )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_FALSE(observerConfig.highlightPlayers); - ASSERT_FALSE(observerConfig.trackAvatar); - ASSERT_FALSE(observerConfig.rotateWithAvatar); - ASSERT_FALSE(observerConfig.rotateAvatarImage); -} + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_FALSE(observerConfig.highlightPlayers); + ASSERT_FALSE(observerConfig.trackAvatar); + ASSERT_FALSE(observerConfig.rotateWithAvatar); + ASSERT_FALSE(observerConfig.rotateAvatarImage); + } -TEST(GDYFactoryTest, loadEnvironment_MultiPlayerNoHighlight) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_MultiPlayerNoHighlight) { + auto yamlString = R"( Environment: Name: Test Player: @@ -704,24 +755,22 @@ TEST(GDYFactoryTest, loadEnvironment_MultiPlayerNoHighlight) { Width: 9 )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_FALSE(observerConfig.highlightPlayers); - ASSERT_TRUE(observerConfig.trackAvatar); -} + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_FALSE(observerConfig.highlightPlayers); + ASSERT_TRUE(observerConfig.trackAvatar); + } -TEST(GDYFactoryTest, loadEnvironment_MultiPlayerHighlight) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, nullptr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_MultiPlayerHighlight) { + auto yamlString = R"( Environment: Name: Test Player: @@ -733,25 +782,22 @@ TEST(GDYFactoryTest, loadEnvironment_MultiPlayerHighlight) { Width: 9 )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - gdyFactory->loadEnvironment(environmentNode); + gdyFactory->loadEnvironment(environmentNode); - auto observerConfig = gdyFactory->getDefaultObserverConfig(); + auto observerConfig = gdyFactory->getDefaultObserverConfig(); - ASSERT_EQ(observerConfig.overrideGridHeight, 9); - ASSERT_EQ(observerConfig.overrideGridWidth, 9); - ASSERT_EQ(observerConfig.gridXOffset, 0); - ASSERT_EQ(observerConfig.gridYOffset, 0); - ASSERT_TRUE(observerConfig.highlightPlayers); - ASSERT_TRUE(observerConfig.trackAvatar); -} + ASSERT_EQ(observerConfig.overrideGridHeight, 9); + ASSERT_EQ(observerConfig.overrideGridWidth, 9); + ASSERT_EQ(observerConfig.gridXOffset, 0); + ASSERT_EQ(observerConfig.gridYOffset, 0); + ASSERT_TRUE(observerConfig.highlightPlayers); + ASSERT_TRUE(observerConfig.trackAvatar); + } -TEST(GDYFactoryTest, loadEnvironment_termination_v1) { - auto mockObjectGeneratorPtr = std::shared_ptr(new MockObjectGenerator()); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_termination_v1) { + auto yamlString = R"( Environment: Name: Test Termination: @@ -766,27 +812,32 @@ TEST(GDYFactoryTest, loadEnvironment_termination_v1) { - lt: [var3, -1] )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::LOSE), Eq(0), Eq(0), Eq(environmentNode["Termination"]["Lose"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::WIN), Eq(0), Eq(0), Eq(environmentNode["Termination"]["Win"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::NONE), Eq(0), Eq(0), Eq(environmentNode["Termination"]["End"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(0), Eq(0), Eq(environmentNode["Termination"]["Truncated"]))) - .Times(1); - - gdyFactory->loadEnvironment(environmentNode); - - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); -} + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::LOSE), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["Lose"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::WIN), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["Win"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::NONE), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["End"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["Truncated"]))) + .Times(1); + + gdyFactory->loadEnvironment(environmentNode); + + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadEnvironment_termination_v2) { - auto mockObjectGeneratorPtr = std::shared_ptr(new MockObjectGenerator()); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadEnvironment_termination_v2) { + auto yamlString = R"( Environment: Name: Test Termination: @@ -822,57 +873,73 @@ TEST(GDYFactoryTest, loadEnvironment_termination_v2) { - lt: [var4, -1] )"; - auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); - - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::LOSE), Eq(-5), Eq(5), Eq(environmentNode["Termination"]["Lose"][0]["Conditions"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::LOSE), Eq(-15), Eq(15), Eq(environmentNode["Termination"]["Lose"][1]["Conditions"]))) - .Times(1); - - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::WIN), Eq(15), Eq(-15), Eq(environmentNode["Termination"]["Win"][0]["Conditions"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::WIN), Eq(0), Eq(0), Eq(environmentNode["Termination"]["Win"][1]["Conditions"]))) - .Times(1); - - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::NONE), Eq(-5), Eq(5), Eq(environmentNode["Termination"]["End"][0]["Conditions"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::NONE), Eq(0), Eq(0), Eq(environmentNode["Termination"]["End"][1]["Conditions"]))) - .Times(1); - - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(-5), Eq(5), Eq(environmentNode["Termination"]["Truncated"][0]["Conditions"]))) - .Times(1); - EXPECT_CALL(*mockTerminationGeneratorPtr, defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(0), Eq(0), Eq(environmentNode["Termination"]["Truncated"][1]["Conditions"]))) - .Times(1); - - gdyFactory->loadEnvironment(environmentNode); - - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); -} + auto environmentNode = loadFromStringAndGetNode(std::string(yamlString), "Environment"); + + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::LOSE), Eq(-5), Eq(5), + Eq(environmentNode["Termination"]["Lose"][0]["Conditions"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::LOSE), Eq(-15), Eq(15), + Eq(environmentNode["Termination"]["Lose"][1]["Conditions"]))) + .Times(1); + + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::WIN), Eq(15), Eq(-15), + Eq(environmentNode["Termination"]["Win"][0]["Conditions"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::WIN), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["Win"][1]["Conditions"]))) + .Times(1); + + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::NONE), Eq(-5), Eq(5), + Eq(environmentNode["Termination"]["End"][0]["Conditions"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::NONE), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["End"][1]["Conditions"]))) + .Times(1); + + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(-5), Eq(5), + Eq(environmentNode["Termination"]["Truncated"][0]["Conditions"]))) + .Times(1); + EXPECT_CALL(*mockTerminationGeneratorPtr, + defineTerminationCondition(Eq(TerminationState::TRUNCATED), Eq(0), Eq(0), + Eq(environmentNode["Termination"]["Truncated"][1]["Conditions"]))) + .Times(1); + + gdyFactory->loadEnvironment(environmentNode); + + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockTerminationGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadObjects) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto objectsNode = loadAndGetNode("tests/resources/loadObjects.yaml", "Objects"); + TEST_F(GDYFactoryTestF, loadObjects) { + auto objectsNode = loadAndGetNode("tests/resources/loadObjects.yaml", "Objects"); - auto expectedVariables = std::unordered_map{{"resources", 0}, {"health", 10}}; + auto expectedVariables = std::unordered_map{{"resources", 0}, + {"health", 10}}; - EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object"), Eq('O'), Eq(0), Eq(expectedVariables))) - .Times(1); + EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object"), Eq('O'), Eq(0), Eq(expectedVariables))) + .Times(1); - EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object_simple_sprite"), Eq('M'), Eq(0), Eq(std::unordered_map{}))) - .Times(1); + EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object_simple_sprite"), Eq('M'), Eq(0), + Eq(std::unordered_map{}))) + .Times(1); - EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object_simple"), Eq('?'), Eq(0), Eq(std::unordered_map{}))) - .Times(1); + EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object_simple"), Eq('?'), Eq(0), + Eq(std::unordered_map{}))) + .Times(1); - gdyFactory->loadObjects(objectsNode); + gdyFactory->loadObjects(objectsNode); - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } -TEST(GDYFactoryTest, load_object_initial_actions) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, load_object_initial_actions) { + auto yamlString = R"( Objects: - Name: object InitialActions: @@ -884,71 +951,27 @@ TEST(GDYFactoryTest, load_object_initial_actions) { )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - - auto objectsNode = loadFromStringAndGetNode(std::string(yamlString), "Objects"); - - EXPECT_CALL(*mockObjectGeneratorPtr, defineNewObject(Eq("object"), Eq('?'), Eq(0), Eq(std::unordered_map{}))) - .Times(1); - - EXPECT_CALL(*mockObjectGeneratorPtr, addInitialAction(Eq("object"), Eq("action_1"), Eq(2), Eq(10), Eq(false))) - .Times(1); - - EXPECT_CALL(*mockObjectGeneratorPtr, addInitialAction(Eq("object"), Eq("action_2"), Eq(0), Eq(0), Eq(true))) - .Times(1); - - gdyFactory->loadObjects(objectsNode); - - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} - -void expectOpposingDefinitionNOP(ActionBehaviourType behaviourType, uint32_t behaviourIdx, std::string sourceObjectName, std::string destinationObjectName, std::shared_ptr mockObjectGeneratorPtr) { - ActionBehaviourDefinition expectedNOPDefinition = GDYFactory::makeBehaviourDefinition( - behaviourType == ActionBehaviourType::DESTINATION ? ActionBehaviourType::SOURCE : ActionBehaviourType::DESTINATION, - behaviourIdx, - behaviourType == ActionBehaviourType::DESTINATION ? sourceObjectName : destinationObjectName, - behaviourType == ActionBehaviourType::SOURCE ? sourceObjectName : destinationObjectName, - "action", - "nop", - {}, - {}, - {}); - auto objectName = behaviourType == ActionBehaviourType::SOURCE ? destinationObjectName : sourceObjectName; + auto objectsNode = loadFromStringAndGetNode(std::string(yamlString), "Objects"); - EXPECT_CALL(*mockObjectGeneratorPtr, defineActionBehaviour(Eq(objectName), ActionBehaviourDefinitionEqMatcher(expectedNOPDefinition))) - .Times(1); -} + EXPECT_CALL(*mockObjectGeneratorPtr, + defineNewObject(Eq("object"), Eq('?'), Eq(0), Eq(std::unordered_map{}))) + .Times(1); -void testBehaviourDefinition(std::string yamlString, ActionBehaviourDefinition expectedBehaviourDefinition, bool expectNOP) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); + EXPECT_CALL(*mockObjectGeneratorPtr, + addInitialAction(Eq("object"), Eq("action_1"), Eq(2), Eq(10), Eq(false))) + .Times(1); - auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + EXPECT_CALL(*mockObjectGeneratorPtr, addInitialAction(Eq("object"), Eq("action_2"), Eq(0), Eq(0), Eq(true))) + .Times(1); - gdyFactory->loadObjects(objectsNode); + gdyFactory->loadObjects(objectsNode); - auto actionsNode = loadFromStringAndGetNode(yamlString, "Actions"); - - auto objectName = expectedBehaviourDefinition.behaviourType == ActionBehaviourType::SOURCE ? expectedBehaviourDefinition.sourceObjectName : expectedBehaviourDefinition.destinationObjectName; - - EXPECT_CALL(*mockObjectGeneratorPtr, defineActionBehaviour(Eq(objectName), ActionBehaviourDefinitionEqMatcher(expectedBehaviourDefinition))) - .Times(1); - - if (expectNOP) { - expectOpposingDefinitionNOP(expectedBehaviourDefinition.behaviourType, expectedBehaviourDefinition.behaviourIdx, expectedBehaviourDefinition.sourceObjectName, expectedBehaviourDefinition.destinationObjectName, mockObjectGeneratorPtr); - } - - gdyFactory->loadActions(actionsNode); - - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } -TEST(GDYFactoryTest, loadAction_source_conditional) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, loadAction_source_conditional) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -966,22 +989,23 @@ TEST(GDYFactoryTest, loadAction_source_conditional) { Object: destinationObject )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::SOURCE, - 0, - "sourceObject", - "destinationObject", - "action", - "eq", - {{"0", _Y("0")}, {"1", _Y("1")}}, - {}, - {{"reward", {{"0", _Y("1")}}}}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_source_named_arguments) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::SOURCE, + 0, + "sourceObject", + "destinationObject", + "action", + "eq", + {{"0", _Y("0")}, + {"1", _Y("1")}}, + {}, + {{"reward", {{"0", _Y("1")}}}}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_source_named_arguments) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -999,22 +1023,24 @@ TEST(GDYFactoryTest, loadAction_source_named_arguments) { Object: destinationObject )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::SOURCE, - 0, - "sourceObject", - "destinationObject", - "action", - "exec", - {{"Action", _Y("other")}, {"Delay", _Y("10")}, {"VectorToDest", _Y("_dest")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_destination) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::SOURCE, + 0, + "sourceObject", + "destinationObject", + "action", + "exec", + {{"Action", _Y("other")}, + {"Delay", _Y("10")}, + {"VectorToDest", _Y("_dest")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_destination) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -1029,22 +1055,22 @@ TEST(GDYFactoryTest, loadAction_destination) { - decr: resources )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "destinationObject", - "sourceObject", - "action", - "decr", - {{"0", _Y("resources")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_destination_conditional) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "destinationObject", + "sourceObject", + "action", + "decr", + {{"0", _Y("resources")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_destination_conditional) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -1062,22 +1088,23 @@ TEST(GDYFactoryTest, loadAction_destination_conditional) { - multi: [0, 1, 2] )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "destinationObject", - "sourceObject", - "action", - "eq", - {{"0", _Y("0")}, {"1", _Y("1")}}, - {}, - {{"multi", {{"0", _Y("0")}, {"1", _Y("1")}, {"2", _Y("2")}}}}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_source_empty) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "destinationObject", + "sourceObject", + "action", + "eq", + {{"0", _Y("0")}, + {"1", _Y("1")}}, + {}, + {{"multi", {{"0", _Y("0")}, {"1", _Y("1")}, {"2", _Y("2")}}}}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_source_empty) { + auto yamlString = R"( Actions: - Name: action Behaviours: @@ -1089,22 +1116,22 @@ TEST(GDYFactoryTest, loadAction_source_empty) { Object: _empty )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::SOURCE, - 0, - "_empty", - "_empty", - "action", - "spawn", - {{"0", _Y("cars")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_dest_empty) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::SOURCE, + 0, + "_empty", + "_empty", + "action", + "spawn", + {{"0", _Y("cars")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_dest_empty) { + auto yamlString = R"( Actions: - Name: action Behaviours: @@ -1116,22 +1143,22 @@ TEST(GDYFactoryTest, loadAction_dest_empty) { - spawn: cars )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "_empty", - "_empty", - "action", - "spawn", - {{"0", _Y("cars")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_destination_missing) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "_empty", + "_empty", + "action", + "spawn", + {{"0", _Y("cars")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_destination_missing) { + auto yamlString = R"( Actions: - Name: action Behaviours: @@ -1141,22 +1168,22 @@ TEST(GDYFactoryTest, loadAction_destination_missing) { - spawn: cars )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::SOURCE, - 0, - "_empty", - "_empty", - "action", - "spawn", - {{"0", _Y("cars")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} - -TEST(GDYFactoryTest, loadAction_src_missing) { - auto yamlString = R"( + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::SOURCE, + 0, + "_empty", + "_empty", + "action", + "spawn", + {{"0", _Y("cars")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + TEST_F(GDYFactoryTestF, loadAction_src_missing) { + auto yamlString = R"( Actions: - Name: action Behaviours: @@ -1166,252 +1193,250 @@ TEST(GDYFactoryTest, loadAction_src_missing) { - spawn: cars )"; - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "_empty", - "_empty", - "action", - "spawn", - {{"0", _Y("cars")}}, - {}, - {}); + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "_empty", + "_empty", + "action", + "spawn", + {{"0", _Y("cars")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + } + + std::map> mockObjectDefs(std::vector objectNames) { + std::map> mockObjectDefinitions; + for (auto name: objectNames) { + ObjectDefinition objectDefinition = { + name}; + mockObjectDefinitions[name] = std::make_shared(objectDefinition); + } + + return mockObjectDefinitions; + } - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); -} + TEST_F(GDYFactoryTestF, wallTest) { -std::map> mockObjectDefs(std::vector objectNames) { - std::map> mockObjectDefinitions; - for (auto name : objectNames) { - ObjectDefinition objectDefinition = { - name}; - mockObjectDefinitions[name] = std::make_shared(objectDefinition); - } + auto grid = std::make_shared(); - return mockObjectDefinitions; -} + auto mockWall2Object = std::make_shared(); + auto mockWall16Object = std::make_shared(); + auto mockDefaultEmptyObject = std::make_shared(); + auto mockDefaultBoundaryObject = std::make_shared(); -TEST(GDYFactoryTest, wallTest) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto grid = std::make_shared(); + std::string wall2String = "Wall2"; + std::string wall16String = "Wall16"; - auto mockWall2Object = std::make_shared(); - auto mockWall16Object = std::make_shared(); - auto mockDefaultEmptyObject = std::make_shared(); - auto mockDefaultBoundaryObject = std::make_shared(); + EXPECT_CALL(*mockWall2Object, getObjectName()) + .WillRepeatedly(ReturnRef(wall2String)); - std::string wall2String = "Wall2"; - std::string wall16String = "Wall16"; + EXPECT_CALL(*mockWall16Object, getObjectName()) + .WillRepeatedly(ReturnRef(wall16String)); - EXPECT_CALL(*mockWall2Object, getObjectName()) - .WillRepeatedly(ReturnRef(wall2String)); + auto objectDefinitions = mockObjectDefs({wall2String, wall16String}); - EXPECT_CALL(*mockWall16Object, getObjectName()) - .WillRepeatedly(ReturnRef(wall16String)); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectDefinitions()) + .WillRepeatedly(ReturnRefOfCopy(objectDefinitions)); - auto objectDefinitions = mockObjectDefs({wall2String, wall16String}); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('*'))) + .WillRepeatedly(ReturnRef(wall2String)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectDefinitions()) - .WillRepeatedly(ReturnRefOfCopy(objectDefinitions)); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('W'))) + .WillRepeatedly(ReturnRef(wall16String)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('*'))) - .WillRepeatedly(ReturnRef(wall2String)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(1), Eq(grid))) + .WillRepeatedly(Return(mockDefaultEmptyObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('W'))) - .WillRepeatedly(ReturnRef(wall16String)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockDefaultEmptyObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(1), Eq(grid))) - .WillRepeatedly(Return(mockDefaultEmptyObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(1), Eq(grid))) + .WillRepeatedly(Return(mockDefaultBoundaryObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockDefaultEmptyObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockDefaultBoundaryObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(1), Eq(grid))) - .WillRepeatedly(Return(mockDefaultBoundaryObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall2String), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockWall2Object)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockDefaultBoundaryObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall16String), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockWall16Object)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall2String), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockWall2Object)); + gdyFactory->initializeFromFile("tests/resources/walls.yaml"); + gdyFactory->getLevelGenerator(0)->reset(grid); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall16String), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockWall16Object)); + ASSERT_EQ(grid->getWidth(), 17); + ASSERT_EQ(grid->getHeight(), 17); - gdyFactory->initializeFromFile("tests/resources/walls.yaml"); - gdyFactory->getLevelGenerator(0)->reset(grid); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); + } - ASSERT_EQ(grid->getWidth(), 17); - ASSERT_EQ(grid->getHeight(), 17); + TEST_F(GDYFactoryTestF, zIndexTest) { - EXPECT_TRUE(Mock::VerifyAndClearExpectations(mockObjectGeneratorPtr.get())); -} + auto grid = std::make_shared(); -TEST(GDYFactoryTest, zIndexTest) { - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto grid = std::make_shared(); + auto mockWallObject = std::make_shared(); + auto mockFloorObject = std::make_shared(); + auto mockGhostObject = std::make_shared(); - auto mockWallObject = std::make_shared(); - auto mockFloorObject = std::make_shared(); - auto mockGhostObject = std::make_shared(); + auto mockDefaultEmptyObject = std::make_shared(); + auto mockDefaultBoundaryObject = std::make_shared(); - auto mockDefaultEmptyObject = std::make_shared(); - auto mockDefaultBoundaryObject = std::make_shared(); + std::string wall = "Wall2"; + std::string floor = "floor"; + std::string ghost = "ghost"; - std::string wall = "Wall2"; - std::string floor = "floor"; - std::string ghost = "ghost"; + EXPECT_CALL(*mockWallObject, getObjectName()) + .WillRepeatedly(ReturnRef(wall)); - EXPECT_CALL(*mockWallObject, getObjectName()) - .WillRepeatedly(ReturnRef(wall)); + EXPECT_CALL(*mockFloorObject, getObjectName()) + .WillRepeatedly(ReturnRef(floor)); - EXPECT_CALL(*mockFloorObject, getObjectName()) - .WillRepeatedly(ReturnRef(floor)); + EXPECT_CALL(*mockGhostObject, getObjectName()) + .WillRepeatedly(ReturnRef(ghost)); - EXPECT_CALL(*mockGhostObject, getObjectName()) - .WillRepeatedly(ReturnRef(ghost)); + auto objectDefinitions = mockObjectDefs({wall, floor, ghost}); - auto objectDefinitions = mockObjectDefs({wall, floor, ghost}); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectDefinitions()) + .WillRepeatedly(ReturnRefOfCopy(objectDefinitions)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectDefinitions()) - .WillRepeatedly(ReturnRefOfCopy(objectDefinitions)); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('*'))) + .WillRepeatedly(ReturnRef(wall)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('*'))) - .WillRepeatedly(ReturnRef(wall)); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('f'))) + .WillRepeatedly(ReturnRef(floor)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('f'))) - .WillRepeatedly(ReturnRef(floor)); + EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('g'))) + .WillRepeatedly(ReturnRef(floor)); - EXPECT_CALL(*mockObjectGeneratorPtr, getObjectNameFromMapChar(Eq('g'))) - .WillRepeatedly(ReturnRef(floor)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(1), Eq(grid))) + .WillRepeatedly(Return(mockDefaultEmptyObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(1), Eq(grid))) - .WillRepeatedly(Return(mockDefaultEmptyObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockDefaultEmptyObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_empty"), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockDefaultEmptyObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(1), Eq(grid))) + .WillRepeatedly(Return(mockDefaultBoundaryObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(1), Eq(grid))) - .WillRepeatedly(Return(mockDefaultBoundaryObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockDefaultBoundaryObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq("_boundary"), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockDefaultBoundaryObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockWallObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(wall), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockWallObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(floor), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockFloorObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(floor), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockFloorObject)); + EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(ghost), Eq(0), Eq(grid))) + .WillRepeatedly(Return(mockGhostObject)); - EXPECT_CALL(*mockObjectGeneratorPtr, newInstance(Eq(ghost), Eq(0), Eq(grid))) - .WillRepeatedly(Return(mockGhostObject)); + gdyFactory->initializeFromFile("tests/resources/ztest.yaml"); + gdyFactory->getLevelGenerator(0)->reset(grid); - gdyFactory->initializeFromFile("tests/resources/ztest.yaml"); - gdyFactory->getLevelGenerator(0)->reset(grid); + ASSERT_EQ(grid->getWidth(), 5); + ASSERT_EQ(grid->getHeight(), 5); + } - ASSERT_EQ(grid->getWidth(), 5); - ASSERT_EQ(grid->getHeight(), 5); -} + MATCHER_P(ActionTriggerMatcherEq, expectedActionTriggerDefinitions, "") { + if (expectedActionTriggerDefinitions.size() != arg.size()) { + return false; + } -MATCHER_P(ActionTriggerMatcherEq, expectedActionTriggerDefinitions, "") { - if (expectedActionTriggerDefinitions.size() != arg.size()) { - return false; - } + for (auto expectedActionTriggerDefinitionsPair: expectedActionTriggerDefinitions) { + auto key = expectedActionTriggerDefinitionsPair.first; + auto expectedActionTriggerDefinition = expectedActionTriggerDefinitionsPair.second; - for (auto expectedActionTriggerDefinitionsPair : expectedActionTriggerDefinitions) { - auto key = expectedActionTriggerDefinitionsPair.first; - auto expectedActionTriggerDefinition = expectedActionTriggerDefinitionsPair.second; + auto actualActionTriggerDefinitionIt = arg.find(key); + if (actualActionTriggerDefinitionIt == arg.end()) { + return false; + } - auto actualActionTriggerDefinitionIt = arg.find(key); - if (actualActionTriggerDefinitionIt == arg.end()) { - return false; - } + auto actualActionTriggerDefinition = actualActionTriggerDefinitionIt->second; - auto actualActionTriggerDefinition = actualActionTriggerDefinitionIt->second; + if (expectedActionTriggerDefinition.sourceObjectNames != + actualActionTriggerDefinition.sourceObjectNames) { + return false; + } - if (expectedActionTriggerDefinition.sourceObjectNames != actualActionTriggerDefinition.sourceObjectNames) { - return false; - } + if (expectedActionTriggerDefinition.destinationObjectNames != + actualActionTriggerDefinition.destinationObjectNames) { + return false; + } - if (expectedActionTriggerDefinition.destinationObjectNames != actualActionTriggerDefinition.destinationObjectNames) { - return false; - } + if (expectedActionTriggerDefinition.triggerType != actualActionTriggerDefinition.triggerType) { + return false; + } - if (expectedActionTriggerDefinition.triggerType != actualActionTriggerDefinition.triggerType) { - return false; - } + if (expectedActionTriggerDefinition.range != actualActionTriggerDefinition.range) { + return false; + } + } - if (expectedActionTriggerDefinition.range != actualActionTriggerDefinition.range) { - return false; + return true; } - } - return true; -} + MATCHER_P(InputMappingMatcherEq, expectedActionInputsDefinitions, "") { + if (expectedActionInputsDefinitions.size() != arg.size()) { + return false; + } -MATCHER_P(InputMappingMatcherEq, expectedActionInputsDefinitions, "") { - if (expectedActionInputsDefinitions.size() != arg.size()) { - return false; - } + for (auto expectedActionInputsDefinitionPair: expectedActionInputsDefinitions) { + auto key = expectedActionInputsDefinitionPair.first; + auto expectedActionInputsDefinition = expectedActionInputsDefinitionPair.second; + auto actualActionInputsDefinitionIt = arg.find(key); - for (auto expectedActionInputsDefinitionPair : expectedActionInputsDefinitions) { - auto key = expectedActionInputsDefinitionPair.first; - auto expectedActionInputsDefinition = expectedActionInputsDefinitionPair.second; - auto actualActionInputsDefinitionIt = arg.find(key); + if (actualActionInputsDefinitionIt == arg.end()) { + return false; + } - if (actualActionInputsDefinitionIt == arg.end()) { - return false; - } + auto actualActionInputsDefinition = actualActionInputsDefinitionIt->second; - auto actualActionInputsDefinition = actualActionInputsDefinitionIt->second; + if (actualActionInputsDefinition.relative != expectedActionInputsDefinition.relative) { + return false; + } - if (actualActionInputsDefinition.relative != expectedActionInputsDefinition.relative) { - return false; - } + if (actualActionInputsDefinition.internal != expectedActionInputsDefinition.internal) { + return false; + } - if (actualActionInputsDefinition.internal != expectedActionInputsDefinition.internal) { - return false; - } + if (actualActionInputsDefinition.mapToGrid != expectedActionInputsDefinition.mapToGrid) { + return false; + } - if (actualActionInputsDefinition.mapToGrid != expectedActionInputsDefinition.mapToGrid) { - return false; - } + auto actualInputMappings = actualActionInputsDefinition.inputMappings; - auto actualInputMappings = actualActionInputsDefinition.inputMappings; + for (auto expectedInputMappingPair: actualActionInputsDefinition.inputMappings) { + auto actionId = expectedInputMappingPair.first; + auto expectedInputMapping = expectedInputMappingPair.second; + auto actualInputMappingIt = actualInputMappings.find(actionId); - for (auto expectedInputMappingPair : actualActionInputsDefinition.inputMappings) { - auto actionId = expectedInputMappingPair.first; - auto expectedInputMapping = expectedInputMappingPair.second; - auto actualInputMappingIt = actualInputMappings.find(actionId); + if (actualInputMappingIt == actualInputMappings.end()) { + return false; + } + auto actualInputMapping = actualInputMappingIt->second; - if (actualInputMappingIt == actualInputMappings.end()) { - return false; - } - auto actualInputMapping = actualInputMappingIt->second; + if (expectedInputMapping.vectorToDest != actualInputMapping.vectorToDest) { + return false; + } - if (expectedInputMapping.vectorToDest != actualInputMapping.vectorToDest) { - return false; - } + if (expectedInputMapping.orientationVector != actualInputMapping.orientationVector) { + return false; + } - if (expectedInputMapping.orientationVector != actualInputMapping.orientationVector) { - return false; - } + if (expectedInputMapping.description != actualInputMapping.description) { + return false; + } + } + } - if (expectedInputMapping.description != actualInputMapping.description) { - return false; - } + return true; } - } - - return true; -} -TEST(GDYFactoryTest, action_input_mapping) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_mapping) { + auto yamlString = R"( Actions: - Name: move InputMapping: @@ -1431,29 +1456,26 @@ TEST(GDYFactoryTest, action_input_mapping) { Relative: true )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + gdyFactory->loadActions(actionsNode); - std::unordered_map expectedInputMappings{ - {"move", {{ - {1, {{1, 0}, {1, 0}, ""}}, - {2, {{0, -1}, {0, -1}, ""}}, - {3, {{-1, 0}, {-1, 0}, ""}}, - {4, {{0, 1}, {0, 1}, ""}}, - }, - true, - false}}}; + std::unordered_map expectedInputMappings{ + {"move", {{ + {1, {{1, 0}, {1, 0}, ""}}, + {2, {{0, -1}, {0, -1}, ""}}, + {3, {{-1, 0}, {-1, 0}, ""}}, + {4, {{0, 1}, {0, 1}, ""}}, + }, + true, + false}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } -TEST(GDYFactoryTest, action_input_default_values) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_default_values) { + auto yamlString = R"( Actions: - Name: move InputMapping: @@ -1469,28 +1491,25 @@ TEST(GDYFactoryTest, action_input_default_values) { Relative: true )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + gdyFactory->loadActions(actionsNode); - std::unordered_map expectedInputMappings{ - {"move", {{ - {1, {{0, 0}, {1, 0}, "Do Something"}}, - {2, {{0, -1}, {0, 0}, ""}}, - {4, {{0, 1}, {0, 1}, ""}}, - }, - true, - false}}}; + std::unordered_map expectedInputMappings{ + {"move", {{ + {1, {{0, 0}, {1, 0}, "Do Something"}}, + {2, {{0, -1}, {0, 0}, ""}}, + {4, {{0, 1}, {0, 1}, ""}}, + }, + true, + false}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } -TEST(GDYFactoryTest, action_input_meta_data) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_meta_data) { + auto yamlString = R"( Actions: - Name: move InputMapping: @@ -1512,77 +1531,68 @@ TEST(GDYFactoryTest, action_input_meta_data) { Relative: true )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + gdyFactory->loadActions(actionsNode); - std::unordered_map expectedInputMappings{ - {"move", {{ - {1, {{0, 0}, {1, 0}, "Do Something", {{"Image", 0}}}}, - {2, {{0, -1}, {0, 0}, "", {{"Image", 1}}}}, - {4, {{0, 1}, {0, 1}, "", {{"Image", 2}}}}, - }, - true, - false}}}; + std::unordered_map expectedInputMappings{ + {"move", {{ + {1, {{0, 0}, {1, 0}, "Do Something", {{"Image", 0}}}}, + {2, {{0, -1}, {0, 0}, "", {{"Image", 1}}}}, + {4, {{0, 1}, {0, 1}, "", {{"Image", 2}}}}, + }, + true, + false}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } -TEST(GDYFactoryTest, action_input_map_to_grid) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_map_to_grid) { + auto yamlString = R"( Actions: - Name: spawn InputMapping: MapToGrid: true )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + gdyFactory->loadActions(actionsNode); - std::unordered_map expectedInputMappings{ - {"spawn", {{}, false, false, true}}}; + std::unordered_map expectedInputMappings{ + {"spawn", {{}, false, false, true}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } -TEST(GDYFactoryTest, action_input_default_mapping) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_default_mapping) { + auto yamlString = R"( Actions: - Name: move )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + gdyFactory->loadActions(actionsNode); - std::unordered_map expectedInputMappings{ - {"move", {{ - {1, {{-1, 0}, {-1, 0}, "Left"}}, - {2, {{0, -1}, {0, -1}, "Up"}}, - {3, {{1, 0}, {1, 0}, "Right"}}, - {4, {{0, 1}, {0, 1}, "Down"}}, - }, - false, - false}}}; + std::unordered_map expectedInputMappings{ + {"move", {{ + {1, {{-1, 0}, {-1, 0}, "Left"}}, + {2, {{0, -1}, {0, -1}, "Up"}}, + {3, {{1, 0}, {1, 0}, "Right"}}, + {4, {{0, 1}, {0, 1}, "Down"}}, + }, + false, + false}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } -TEST(GDYFactoryTest, action_input_internal_mapping) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_input_internal_mapping) { + auto yamlString = R"( Actions: - Name: player_move - Name: other_move @@ -1591,48 +1601,45 @@ TEST(GDYFactoryTest, action_input_internal_mapping) { Internal: true )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - - gdyFactory->loadActions(actionsNode); - - std::unordered_map expectedInputMappings{ - {"player_move", - {{ - {1, {{-1, 0}, {-1, 0}, "Left"}}, - {2, {{0, -1}, {0, -1}, "Up"}}, - {3, {{1, 0}, {1, 0}, "Right"}}, - {4, {{0, 1}, {0, 1}, "Down"}}, - }, - false, - false}}, - {"other_move", - {{ - {1, {{-1, 0}, {-1, 0}, "Left"}}, - {2, {{0, -1}, {0, -1}, "Up"}}, - {3, {{1, 0}, {1, 0}, "Right"}}, - {4, {{0, 1}, {0, 1}, "Down"}}, - }, - false, - false}}, - {"internal_move", - {{ - {1, {{-1, 0}, {-1, 0}, "Left"}}, - {2, {{0, -1}, {0, -1}, "Up"}}, - {3, {{1, 0}, {1, 0}, "Right"}}, - {4, {{0, 1}, {0, 1}, "Down"}}, - }, - false, - true}}}; - - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); -} - -TEST(GDYFactoryTest, action_range_trigger) { - auto yamlString = R"( + + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + + gdyFactory->loadActions(actionsNode); + + std::unordered_map expectedInputMappings{ + {"player_move", + {{ + {1, {{-1, 0}, {-1, 0}, "Left"}}, + {2, {{0, -1}, {0, -1}, "Up"}}, + {3, {{1, 0}, {1, 0}, "Right"}}, + {4, {{0, 1}, {0, 1}, "Down"}}, + }, + false, + false}}, + {"other_move", + {{ + {1, {{-1, 0}, {-1, 0}, "Left"}}, + {2, {{0, -1}, {0, -1}, "Up"}}, + {3, {{1, 0}, {1, 0}, "Right"}}, + {4, {{0, 1}, {0, 1}, "Down"}}, + }, + false, + false}}, + {"internal_move", + {{ + {1, {{-1, 0}, {-1, 0}, "Left"}}, + {2, {{0, -1}, {0, -1}, "Up"}}, + {3, {{1, 0}, {1, 0}, "Right"}}, + {4, {{0, 1}, {0, 1}, "Down"}}, + }, + false, + true}}}; + + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + } + + TEST_F(GDYFactoryTestF, action_range_trigger) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -1652,43 +1659,40 @@ TEST(GDYFactoryTest, action_range_trigger) { )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); - gdyFactory->loadObjects(objectsNode); + auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + gdyFactory->loadObjects(objectsNode); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + gdyFactory->loadActions(actionsNode); - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "destinationObject", - "sourceObject", - "action", - "decr", - {{"0", _Y("resources")}}, - {}, - {}); + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "destinationObject", + "sourceObject", + "action", + "decr", + {{"0", _Y("resources")}}, + {}, + {}); - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); - // Internal should be true and there is no input mapping - std::unordered_map expectedInputMappings{ - {"action", {{}, false, true}}}; + // Internal should be true and there is no input mapping + std::unordered_map expectedInputMappings{ + {"action", {{}, false, true}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); - std::unordered_map expectedTriggerDefinitions{ - {"action", {{"sourceObject"}, {"destinationObject"}, TriggerType::RANGE_BOX_BOUNDARY, 3}}}; + std::unordered_map expectedTriggerDefinitions{ + {"action", {{"sourceObject"}, {"destinationObject"}, TriggerType::RANGE_BOX_BOUNDARY, 3}}}; - ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); -} + ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); + } -TEST(GDYFactoryTest, action_range_default_trigger_type) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_range_default_trigger_type) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -1707,43 +1711,40 @@ TEST(GDYFactoryTest, action_range_default_trigger_type) { )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); - gdyFactory->loadObjects(objectsNode); + auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + gdyFactory->loadObjects(objectsNode); - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + gdyFactory->loadActions(actionsNode); - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "destinationObject", - "sourceObject", - "action", - "decr", - {{"0", _Y("resources")}}, - {}, - {}); + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "destinationObject", + "sourceObject", + "action", + "decr", + {{"0", _Y("resources")}}, + {}, + {}); - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); - // Internal should be true and there is no input mapping - std::unordered_map expectedInputMappings{ - {"action", {{}, false, true}}}; + // Internal should be true and there is no input mapping + std::unordered_map expectedInputMappings{ + {"action", {{}, false, true}}}; - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); - std::unordered_map expectedTriggerDefinitions{ - {"action", {{"sourceObject"}, {"destinationObject"}, TriggerType::RANGE_BOX_AREA, 3}}}; + std::unordered_map expectedTriggerDefinitions{ + {"action", {{"sourceObject"}, {"destinationObject"}, TriggerType::RANGE_BOX_AREA, 3}}}; - ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); -} + ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); + } -TEST(GDYFactoryTest, action_no_triggers) { - auto yamlString = R"( + TEST_F(GDYFactoryTestF, action_no_triggers) { + auto yamlString = R"( Objects: - Name: sourceObject - Name: destinationObject @@ -1759,45 +1760,42 @@ TEST(GDYFactoryTest, action_no_triggers) { )"; - auto mockObjectGeneratorPtr = std::make_shared(); - auto mockTerminationGeneratorPtr = std::make_shared(); - auto gdyFactory = std::shared_ptr(new GDYFactory(mockObjectGeneratorPtr, mockTerminationGeneratorPtr, {})); - - auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); - gdyFactory->loadObjects(objectsNode); - - auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); - gdyFactory->loadActions(actionsNode); - - ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( - ActionBehaviourType::DESTINATION, - 0, - "destinationObject", - "sourceObject", - "action", - "decr", - {{"0", _Y("resources")}}, - {}, - {}); - - testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); - - // Internal should be true and there is no input mapping - std::unordered_map expectedInputMappings{ - {"action", {{ - {1, {{-1, 0}, {-1, 0}, "Left"}}, - {2, {{0, -1}, {0, -1}, "Up"}}, - {3, {{1, 0}, {1, 0}, "Right"}}, - {4, {{0, 1}, {0, 1}, "Down"}}, - }, - false, - false}}}; - - ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); - - std::unordered_map expectedTriggerDefinitions{}; - - ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); -} + + auto objectsNode = loadFromStringAndGetNode(yamlString, "Objects"); + gdyFactory->loadObjects(objectsNode); + + auto actionsNode = loadFromStringAndGetNode(std::string(yamlString), "Actions"); + gdyFactory->loadActions(actionsNode); + + ActionBehaviourDefinition expectedBehaviourDefinition = GDYFactory::makeBehaviourDefinition( + ActionBehaviourType::DESTINATION, + 0, + "destinationObject", + "sourceObject", + "action", + "decr", + {{"0", _Y("resources")}}, + {}, + {}); + + testBehaviourDefinition(yamlString, expectedBehaviourDefinition, true); + + // Internal should be true and there is no input mapping + std::unordered_map expectedInputMappings{ + {"action", {{ + {1, {{-1, 0}, {-1, 0}, "Left"}}, + {2, {{0, -1}, {0, -1}, "Up"}}, + {3, {{1, 0}, {1, 0}, "Right"}}, + {4, {{0, 1}, {0, 1}, "Down"}}, + }, + false, + false}}}; + + ASSERT_THAT(gdyFactory->getActionInputsDefinitions(), InputMappingMatcherEq(expectedInputMappings)); + + std::unordered_map expectedTriggerDefinitions{}; + + ASSERT_THAT(gdyFactory->getActionTriggerDefinitions(), ActionTriggerMatcherEq(expectedTriggerDefinitions)); + } } // namespace griddly \ No newline at end of file