diff --git a/CMakeLists.txt b/CMakeLists.txt index 1152fc1b..88dacfde 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -248,7 +248,7 @@ set (LOOT_TESTS_HEADERS "${CMAKE_SOURCE_DIR}/src/tests/base_game_test.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/conditional_metadata_test.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/file_test.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/location_test.h" - "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/test_message.h" + "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/message_test.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/test_message_content.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/test_plugin_dirty_info.h" "${CMAKE_SOURCE_DIR}/src/tests/backend/metadata/test_plugin_metadata.h" diff --git a/src/tests/backend/metadata/message_test.h b/src/tests/backend/metadata/message_test.h new file mode 100644 index 00000000..8a375de4 --- /dev/null +++ b/src/tests/backend/metadata/message_test.h @@ -0,0 +1,431 @@ +/* LOOT + +A load order optimisation tool for Oblivion, Skyrim, Fallout 3 and +Fallout: New Vegas. + +Copyright (C) 2014-2016 WrinklyNinja + +This file is part of LOOT. + +LOOT is free software: you can redistribute +it and/or modify it under the terms of the GNU General Public License +as published by the Free Software Foundation, either version 3 of +the License, or (at your option) any later version. + +LOOT is distributed in the hope that it will +be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with LOOT. If not, see +. +*/ + +#ifndef LOOT_TEST_BACKEND_METADATA_MESSAGE +#define LOOT_TEST_BACKEND_METADATA_MESSAGE + +#include "backend/game/game.h" +#include "backend/metadata/message.h" +#include "tests/base_game_test.h" + +namespace loot { + namespace test { + class MessageTest : public BaseGameTest { + protected: + + typedef std::vector MessageContents; + }; + + // Pass an empty first argument, as it's a prefix for the test instantation, + // but we only have the one so no prefix is necessary. + INSTANTIATE_TEST_CASE_P(, + MessageTest, + ::testing::Values( + GameSettings::tes4)); + + TEST_P(MessageTest, defaultConstructorShouldCreateNoteWithNoContent) { + Message message; + EXPECT_EQ(Message::say, message.Type()); + EXPECT_EQ(MessageContents(), message.Content()); + } + + TEST_P(MessageTest, scalarContentConstructorShouldCreateAMessageWithASingleContentString) { + MessageContent content = MessageContent("content1", Language::english); + Message message(Message::warn, content.Str(), "condition1"); + + EXPECT_EQ(Message::warn, message.Type()); + EXPECT_EQ(MessageContents({content}), message.Content()); + EXPECT_EQ("condition1", message.Condition()); + } + + TEST_P(MessageTest, vectorContentConstructorShouldCreateAMessageWithGivenContentStrings) { + MessageContents contents({ + MessageContent("content1", Language::english), + MessageContent("content2", Language::french), + }); + Message message(Message::error, contents, "condition1"); + + EXPECT_EQ(Message::error, message.Type()); + EXPECT_EQ(contents, message.Content()); + EXPECT_EQ("condition1", message.Condition()); + } + + TEST_P(MessageTest, messagesWithDifferentContentStringsShouldBeUnequal) { + Message message1(Message::say, "content1", "condition1"); + Message message2(Message::say, "content2", "condition1"); + + EXPECT_FALSE(message1 == message2); + } + + TEST_P(MessageTest, messagesWithEqualContentStringsShouldBeEqual) { + Message message1(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); + Message message2(Message::warn, MessageContents({MessageContent("content1", Language::french)}), "condition2"); + + EXPECT_TRUE(message1 == message2); + } + + TEST_P(MessageTest, LessThanOperatorShouldUseCaseInsensitiveLexicographicalContentStringComparison) { + Message message1(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); + Message message2(Message::warn, MessageContents({MessageContent("content1", Language::french)}), "condition2"); + EXPECT_FALSE(message1 < message2); + EXPECT_FALSE(message2 < message1); + + message1 = Message(Message::say, "content1", "condition1"); + message2 = Message(Message::say, "content2", "condition1"); + EXPECT_TRUE(message1 < message2); + EXPECT_FALSE(message2 < message1); + } + + TEST_P(MessageTest, evalConditionShouldCreateADefaultContentObjectIfNoneExists) { + Game game(GetParam()); + game.SetGamePath(dataPath.parent_path()); + ASSERT_NO_THROW(game.Init(false, localPath)); + + Message message; + EXPECT_TRUE(message.EvalCondition(game, Language::english)); + EXPECT_EQ(MessageContents({MessageContent()}), message.Content()); + } + + TEST_P(MessageTest, evalConditionShouldPickOneContentStringIfMoreThanOneExists) { + Game game(GetParam()); + game.SetGamePath(dataPath.parent_path()); + ASSERT_NO_THROW(game.Init(false, localPath)); + + Message message(Message::say, MessageContents({ + MessageContent("content1", Language::german), + MessageContent("content2", Language::english), + MessageContent("content3", Language::french), + })); + + EXPECT_TRUE(message.EvalCondition(game, Language::french)); + EXPECT_EQ(1, message.Content().size()); + EXPECT_EQ(MessageContent("content3", Language::french), message.Content()[0]); + } + + TEST_P(MessageTest, chooseContentShouldCreateADefaultContentObjectIfNoneExists) { + EXPECT_EQ(MessageContent(), Message().ChooseContent(Language::english)); + } + + TEST_P(MessageTest, chooseContentShouldLeaveTheContentUnchangedIfOnlyOneStringExists) { + MessageContent content("content1", Language::english); + Message message(Message::say, MessageContents({content})); + + EXPECT_EQ(content, message.ChooseContent(Language::french)); + EXPECT_EQ(content, message.ChooseContent(Language::english)); + } + + TEST_P(MessageTest, chooseContentShouldSelectTheEnglishStringIfNoStringExistsForTheGivenLanguage) { + MessageContent content("content1", Language::english); + Message message(Message::say, MessageContents({ + content, + MessageContent("content1", Language::german), + })); + EXPECT_EQ(content, message.ChooseContent(Language::french)); + } + + TEST_P(MessageTest, chooseContentShouldSelectTheStringForTheGivenLanguageIfOneExists) { + MessageContent french("content3", Language::french); + Message message(Message::say, MessageContents({ + MessageContent("content1", Language::german), + MessageContent("content2", Language::english), + french, + })); + + EXPECT_EQ(french, message.ChooseContent(Language::french)); + } + + TEST_P(MessageTest, emittingAsYamlShouldOutputNoteMessageTypeCorrectly) { + Message message(Message::say, "content1"); + YAML::Emitter emitter; + emitter << message; + + EXPECT_STREQ("type: say\n" + "content: 'content1'", emitter.c_str()); + } + + TEST_P(MessageTest, emittingAsYamlShouldOutputWarnMessageTypeCorrectly) { + Message message(Message::warn, "content1"); + YAML::Emitter emitter; + emitter << message; + + EXPECT_STREQ("type: warn\n" + "content: 'content1'", emitter.c_str()); + } + + TEST_P(MessageTest, emittingAsYamlShouldOutputErrorMessageTypeCorrectly) { + Message message(Message::error, "content1"); + YAML::Emitter emitter; + emitter << message; + + EXPECT_STREQ("type: error\n" + "content: 'content1'", emitter.c_str()); + } + + TEST_P(MessageTest, emittingAsYamlShouldOutputConditionIfItIsNotEmpty) { + Message message(Message::say, "content1", "condition1"); + YAML::Emitter emitter; + emitter << message; + + EXPECT_STREQ("type: say\n" + "content: 'content1'\n" + "condition: 'condition1'", emitter.c_str()); + } + + TEST_P(MessageTest, emittingAsYamlShouldOutputMultipleContentStringsAsAList) { + Message message(Message::say, MessageContents({ + MessageContent("content1", Language::english), + MessageContent("content2", Language::german) + })); + YAML::Emitter emitter; + emitter << message; + + EXPECT_STREQ("type: say\n" + "content:\n" + " - lang: en\n" + " str: 'content1'\n" + " - lang: de\n" + " str: 'content2'", emitter.c_str()); + } + + TEST_P(MessageTest, encodingAsYamlShouldStoreNoteMessageTypeCorrectly) { + Message message(Message::say, "content1"); + YAML::Node node; + node = message; + + EXPECT_EQ("say", node["type"].as()); + } + + TEST_P(MessageTest, encodingAsYamlShouldStoreWarningMessageTypeCorrectly) { + Message message(Message::warn, "content1"); + YAML::Node node; + node = message; + + EXPECT_EQ("warn", node["type"].as()); + } + + TEST_P(MessageTest, encodingAsYamlShouldStoreErrorMessageTypeCorrectly) { + Message message(Message::error, "content1"); + YAML::Node node; + node = message; + + EXPECT_EQ("error", node["type"].as()); + } + + TEST_P(MessageTest, encodingAsYamlShouldOmitConditionFieldIfItIsEmpty) { + Message message(Message::say, "content1"); + YAML::Node node; + node = message; + + EXPECT_FALSE(node["condition"]); + } + + TEST_P(MessageTest, encodingAsYamlShouldStoreConditionFieldIfItIsNotEmpty) { + Message message(Message::say, "content1", "condition1"); + YAML::Node node; + node = message; + + EXPECT_EQ("condition1", node["condition"].as()); + } + + TEST_P(MessageTest, encodingAsYamlShouldStoreASingleContentStringInAVector) { + Message message(Message::say, "content1"); + YAML::Node node; + node = message; + + EXPECT_EQ(message.Content(), node["content"].as()); + } + + TEST_P(MessageTest, encodingAsYamlShouldMultipleContentStringsInAVector) { + MessageContents contents({ + MessageContent("content1", Language::english), + MessageContent("content2", Language::french), + }); + Message message(Message::say, contents); + YAML::Node node; + node = message; + + EXPECT_EQ(contents, node["content"].as()); + } + + TEST_P(MessageTest, decodingFromYamlShouldSetNoteTypeCorrectly) { + YAML::Node node = YAML::Load("type: say\n" + "content: content1"); + Message message = node.as(); + + EXPECT_EQ(Message::say, message.Type()); + } + + TEST_P(MessageTest, decodingFromYamlShouldSetWarningTypeCorrectly) { + YAML::Node node = YAML::Load("type: warn\n" + "content: content1"); + Message message = node.as(); + + EXPECT_EQ(Message::warn, message.Type()); + } + + TEST_P(MessageTest, decodingFromYamlShouldSetErrorTypeCorrectly) { + YAML::Node node = YAML::Load("type: error\n" + "content: content1"); + Message message = node.as(); + + EXPECT_EQ(Message::error, message.Type()); + } + + TEST_P(MessageTest, decodingFromYamlShouldHandleAnUnrecognisedTypeAsANote) { + YAML::Node node = YAML::Load("type: invalid\n" + "content: content1"); + Message message = node.as(); + + EXPECT_EQ(Message::say, message.Type()); + } + + TEST_P(MessageTest, decodingFromYamlShouldLeaveTheConditionEmptyIfNoneIsPresent) { + YAML::Node node = YAML::Load("type: say\n" + "content: content1"); + Message message = node.as(); + + EXPECT_TRUE(message.Condition().empty()); + } + + TEST_P(MessageTest, decodingFromYamlShouldStoreANonEmptyConditionField) { + YAML::Node node = YAML::Load("type: say\n" + "content: content1\n" + "condition: 'file(\"Foo.esp\")'"); + Message message = node.as(); + + EXPECT_EQ("file(\"Foo.esp\")", message.Condition()); + } + + TEST_P(MessageTest, decodingFromYamlShouldStoreAScalarContentValueCorrectly) { + YAML::Node node = YAML::Load("type: say\n" + "content: content1\n"); + Message message = node.as(); + MessageContents expectedContent({MessageContent("content1", Language::english)}); + + EXPECT_EQ(expectedContent, message.Content()); + } + + TEST_P(MessageTest, decodingFromYamlShouldStoreAListOfContentStringsCorrectly) { + YAML::Node node = YAML::Load("type: say\n" + "content:\n" + " - lang: en\n" + " str: content1\n" + " - lang: de\n" + " str: content2"); + Message message = node.as(); + + EXPECT_EQ(MessageContents({ + MessageContent("content1", Language::english), + MessageContent("content2", Language::german), + }), message.Content()); + } + + TEST_P(MessageTest, decodingFromYamlShouldNotThrowIfTheOnlyContentStringIsNotEnglish) { + YAML::Node node = YAML::Load("type: say\n" + "content:\n" + " - lang: fr\n" + " str: content1"); + + EXPECT_NO_THROW(Message message = node.as()); + } + + TEST_P(MessageTest, decodingFromYamlShouldThrowIfMultipleContentStringsAreGivenAndNoneAreEnglish) { + YAML::Node node = YAML::Load("type: say\n" + "content:\n" + " - lang: de\n" + " str: content1\n" + " - lang: fr\n" + " str: content2"); + + EXPECT_THROW(node.as(), YAML::RepresentationException); + } + + TEST_P(MessageTest, decodingFromYamlShouldApplySubstitutionsWhenThereIsOnlyOneContentString) { + YAML::Node node = YAML::Load("type: say\n" + "content: con%1%tent1\n" + "subs:\n" + " - sub1"); + Message message = node.as(); + + EXPECT_EQ(MessageContents({MessageContent("consub1tent1", Language::english)}), message.Content()); + } + + TEST_P(MessageTest, decodingFromYamlShouldApplySubstitutionsToAllContentStrings) { + YAML::Node node = YAML::Load("type: say\n" + "content:\n" + " - lang: en\n" + " str: content1 %1%\n" + " - lang: de\n" + " str: content2 %1%\n" + "subs:\n" + " - sub"); + Message message = node.as(); + + EXPECT_EQ(MessageContents({ + MessageContent("content1 sub", Language::english), + MessageContent("content2 sub", Language::german), + }), message.Content()); + } + + TEST_P(MessageTest, decodingFromYamlShouldThrowIfTheContentStringExpectsMoreSubstitutionsThanExist) { + YAML::Node node = YAML::Load("type: say\n" + "content: '%1% %2%'\n" + "subs:\n" + " - sub1"); + + EXPECT_THROW(node.as(), YAML::RepresentationException); + } + + // Don't throw because no subs are given, so none are expected in the content string. + TEST_P(MessageTest, decodingFromYamlShouldIgnoreSubstitutionSyntaxIfNoSubstitutionsExist) { + YAML::Node node = YAML::Load("type: say\n" + "content: con%1%tent1\n"); + Message message = node.as(); + + EXPECT_EQ(MessageContents({MessageContent("con%1%tent1", Language::english)}), message.Content()); + } + + TEST_P(MessageTest, decodingFromYamlShouldThrowIfAnInvalidConditionIsGiven) { + YAML::Node node = YAML::Load("type: say\n" + "content: content1\n" + "condition: invalid"); + + EXPECT_THROW(node.as(), YAML::RepresentationException); + } + + TEST_P(MessageTest, decodingFromYamlShouldThrowIfAScalarIsGiven) { + YAML::Node node = YAML::Load("scalar"); + + EXPECT_THROW(node.as(), YAML::RepresentationException); + } + + TEST_P(MessageTest, decodingFromYamlShouldThrowIfAListIsGiven) { + YAML::Node node = YAML::Load("[0, 1, 2]"); + + EXPECT_THROW(node.as(), YAML::RepresentationException); + } + } +} + +#endif diff --git a/src/tests/backend/metadata/test_message.h b/src/tests/backend/metadata/test_message.h deleted file mode 100644 index b561e223..00000000 --- a/src/tests/backend/metadata/test_message.h +++ /dev/null @@ -1,421 +0,0 @@ -/* LOOT - -A load order optimisation tool for Oblivion, Skyrim, Fallout 3 and -Fallout: New Vegas. - -Copyright (C) 2014-2016 WrinklyNinja - -This file is part of LOOT. - -LOOT is free software: you can redistribute -it and/or modify it under the terms of the GNU General Public License -as published by the Free Software Foundation, either version 3 of -the License, or (at your option) any later version. - -LOOT is distributed in the hope that it will -be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with LOOT. If not, see -. -*/ - -#ifndef LOOT_TEST_BACKEND_METADATA_MESSAGE -#define LOOT_TEST_BACKEND_METADATA_MESSAGE - -#include "backend/metadata/message.h" -#include "tests/fixtures.h" - -namespace loot { - namespace test { - class MessageTest : public SkyrimTest {}; - - typedef std::vector MessageContents; - - TEST_F(MessageTest, ConstructorsAndDataAccess) { - Message message; - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents(), message.Content()); - - message = Message(Message::say, "content1", "condition1"); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({ - MessageContent("content1", Language::english) - }), message.Content()); - EXPECT_EQ("condition1", message.Condition()); - - MessageContents mc({MessageContent("content1", Language::english)}); - message = Message(Message::say, mc, "condition1"); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(mc, message.Content()); - EXPECT_EQ("condition1", message.Condition()); - } - - TEST_F(MessageTest, EqualityOperator) { - Message message1, message2; - EXPECT_TRUE(message1 == message2); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, "content1", "condition2"); - EXPECT_TRUE(message1 == message2); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, "content2", "condition1"); - EXPECT_FALSE(message1 == message2); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::warn, "content1", "condition1"); - EXPECT_TRUE(message1 == message2); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - EXPECT_TRUE(message1 == message2); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content2", Language::english)}), "condition1"); - EXPECT_FALSE(message1 == message2); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - EXPECT_TRUE(message1 == message2); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content2", Language::english)}), "condition1"); - EXPECT_FALSE(message1 == message2); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::french)}), "condition1"); - EXPECT_TRUE(message1 == message2); - } - - TEST_F(MessageTest, LessThanOperator) { - Message message1, message2; - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, "content1", "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, "content1", "condition2"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::warn, "content1", "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "", "condition1"); - message2 = Message(Message::say, "content1", "condition1"); - EXPECT_TRUE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, "", "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_TRUE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, "content1", "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content2", Language::english)}), "condition1"); - EXPECT_TRUE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content2", Language::english)}), "condition1"); - EXPECT_TRUE(message1 < message2); - EXPECT_FALSE(message2 < message1); - - message1 = Message(Message::say, MessageContents({MessageContent("content1", Language::english)}), "condition1"); - message2 = Message(Message::say, MessageContents({MessageContent("content1", Language::french)}), "condition1"); - EXPECT_FALSE(message1 < message2); - EXPECT_FALSE(message2 < message1); - } - - TEST_F(MessageTest, EvalCondition) { - Game game(Game::tes5); - game.SetGamePath(dataPath.parent_path()); - ASSERT_NO_THROW(game.Init(false, localPath)); - - Message message; - EXPECT_TRUE(message.EvalCondition(game, Language::english)); - EXPECT_EQ(1, message.Content().size()); - - message = Message(Message::say, MessageContents({ - MessageContent("content1", Language::german), - MessageContent("content1", Language::english), - MessageContent("content1", Language::french), - })); - EXPECT_TRUE(message.EvalCondition(game, Language::french)); - EXPECT_EQ(1, message.Content().size()); - } - - TEST_F(MessageTest, ChooseContent) { - MessageContent mc; - Message message; - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - EXPECT_EQ(mc, message.ChooseContent(Language::french)); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - - mc = MessageContent("content1", Language::english); - message = Message(Message::say, "content1"); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - EXPECT_EQ(mc, message.ChooseContent(Language::french)); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - - mc = MessageContent("content1", Language::english); - message = Message(Message::say, MessageContents({mc})); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - EXPECT_EQ(mc, message.ChooseContent(Language::french)); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - - mc = MessageContent("content1", Language::english); - message = Message(Message::say, MessageContents({ - MessageContent("content1", Language::english), - MessageContent("content1", Language::german), - })); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - EXPECT_EQ(mc, message.ChooseContent(Language::french)); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - - message = Message(Message::say, MessageContents({ - MessageContent("content1", Language::german), - MessageContent("content1", Language::english), - MessageContent("content1", Language::french), - })); - EXPECT_EQ(MessageContent("content1", Language::german), message.ChooseContent(Language::english)); - EXPECT_EQ(MessageContent("content1", Language::french), message.ChooseContent(Language::french)); - EXPECT_EQ(MessageContent("content1", Language::english), message.ChooseContent(Language::english)); - - mc = MessageContent("content1", Language::german); - message = Message(Message::say, MessageContents({mc})); - EXPECT_EQ(mc, message.ChooseContent(Language::english)); - EXPECT_EQ(mc, message.ChooseContent(Language::french)); - } - - TEST_F(MessageTest, YamlEmitter) { - Message message(Message::say, "content1"); - YAML::Emitter e1; - e1 << message; - EXPECT_STREQ("type: say\n" - "content: 'content1'", e1.c_str()); - - message = Message(Message::warn, "content1"); - YAML::Emitter e2; - e2 << message; - EXPECT_STREQ("type: warn\n" - "content: 'content1'", e2.c_str()); - - message = Message(Message::error, "content1"); - YAML::Emitter e3; - e3 << message; - EXPECT_STREQ("type: error\n" - "content: 'content1'", e3.c_str()); - - message = Message(Message::say, "content1", "condition1"); - YAML::Emitter e4; - e4 << message; - EXPECT_STREQ("type: say\n" - "content: 'content1'\n" - "condition: 'condition1'", e4.c_str()); - - message = Message(Message::say, MessageContents({ - MessageContent("content1", Language::english), - })); - YAML::Emitter e5; - e5 << message; - EXPECT_STREQ("type: say\n" - "content: 'content1'", e5.c_str()); - - message = Message(Message::say, MessageContents({ - MessageContent("content1", Language::english), - MessageContent("content2", Language::german) - })); - YAML::Emitter e6; - e6 << message; - EXPECT_STREQ("type: say\n" - "content:\n" - " - lang: en\n" - " str: 'content1'\n" - " - lang: de\n" - " str: 'content2'", e6.c_str()); - } - - TEST_F(MessageTest, YamlEncode) { - YAML::Node node; - - MessageContents mcs({MessageContent("content1", Language::english)}); - Message message(Message::say, "content1"); - node = message; - EXPECT_EQ("say", node["type"].as()); - EXPECT_EQ(mcs, node["content"].as()); - EXPECT_FALSE(node["condition"]); - - message = Message(Message::warn, "content1"); - node = message; - EXPECT_EQ("warn", node["type"].as()); - EXPECT_EQ(mcs, node["content"].as()); - EXPECT_FALSE(node["condition"]); - - message = Message(Message::error, "content1"); - node = message; - EXPECT_EQ("error", node["type"].as()); - EXPECT_EQ(mcs, node["content"].as()); - EXPECT_FALSE(node["condition"]); - - message = Message(Message::say, "content1", "condition1"); - node = message; - EXPECT_EQ("say", node["type"].as()); - EXPECT_EQ(mcs, node["content"].as()); - EXPECT_EQ("condition1", node["condition"].as()); - - mcs = MessageContents({ - MessageContent("content1", Language::english), - MessageContent("content2", Language::french), - }); - message = Message(Message::say, mcs); - node = message; - EXPECT_EQ("say", node["type"].as()); - EXPECT_EQ(mcs, node["content"].as()); - EXPECT_FALSE(node["condition"]); - } - - TEST_F(MessageTest, YamlDecode) { - YAML::Node node = YAML::Load("type: say\n" - "content: content1"); - Message message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: warn\n" - "content: content1"); - message = node.as(); - EXPECT_EQ(Message::warn, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: error\n" - "content: content1"); - message = node.as(); - EXPECT_EQ(Message::error, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: invalid\n" - "content: content1"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: say\n" - "content: content1\n" - "condition: 'file(\"Foo.esp\")'"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::english)}), message.Content()); - EXPECT_EQ("file(\"Foo.esp\")", message.Condition()); - - node = YAML::Load("type: say\n" - "content:\n" - " - lang: en\n" - " str: content1\n" - " - lang: de\n" - " str: content2"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({ - MessageContent("content1", Language::english), - MessageContent("content2", Language::german), - }), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: say\n" - "content:\n" - " - lang: fr\n" - " str: content1"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("content1", Language::french)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - // Throw because no English string is given in a multilingual message. - node = YAML::Load("type: say\n" - "content:\n" - " - lang: de\n" - " str: content1\n" - " - lang: fr\n" - " str: content2"); - EXPECT_THROW(node.as(), YAML::RepresentationException); - - node = YAML::Load("type: say\n" - "content: con%1%tent1\n" - "subs:\n" - " - sub1"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("consub1tent1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - // Check that subs apply to all languages of a multilingual message. - node = YAML::Load("type: say\n" - "content:\n" - " - lang: en\n" - " str: content1 %1%\n" - " - lang: de\n" - " str: content2 %1%\n" - "subs:\n" - " - sub"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({ - MessageContent("content1 sub", Language::english), - MessageContent("content2 sub", Language::german), - }), message.Content()); - EXPECT_EQ("", message.Condition()); - - // Throw because there aren't the same number of subs as referred to in the content string. - node = YAML::Load("type: say\n" - "content: '%1% %2%'\n" - "subs:\n" - " - sub1"); - EXPECT_THROW(node.as(), YAML::RepresentationException); - - // Don't throw because no subs are given, so none are expected in the content string. - node = YAML::Load("type: say\n" - "content: con%1%tent1\n"); - message = node.as(); - EXPECT_EQ(Message::say, message.Type()); - EXPECT_EQ(MessageContents({MessageContent("con%1%tent1", Language::english)}), message.Content()); - EXPECT_EQ("", message.Condition()); - - node = YAML::Load("type: say\n" - "content: content1\n" - "condition: invalid"); - EXPECT_THROW(node.as(), YAML::RepresentationException); - - node = YAML::Load("scalar"); - EXPECT_THROW(node.as(), YAML::RepresentationException); - - node = YAML::Load("[0, 1, 2]"); - EXPECT_THROW(node.as(), YAML::RepresentationException); - } - } -} - -#endif diff --git a/src/tests/main.cpp b/src/tests/main.cpp index 7d4aab65..a3ef1ed5 100644 --- a/src/tests/main.cpp +++ b/src/tests/main.cpp @@ -54,7 +54,7 @@ #include "backend/metadata/conditional_metadata_test.h" #include "backend/metadata/file_test.h" #include "backend/metadata/location_test.h" -#include "backend/metadata/test_message.h" +#include "backend/metadata/message_test.h" #include "backend/metadata/test_message_content.h" #include "backend/metadata/test_plugin_dirty_info.h" #include "backend/metadata/test_plugin_metadata.h"