diff --git a/cpp/src/tests/api/interface/metadata/message_content_test.h b/cpp/src/tests/api/interface/metadata/message_content_test.h index cda9b905..57172ce9 100644 --- a/cpp/src/tests/api/interface/metadata/message_content_test.h +++ b/cpp/src/tests/api/interface/metadata/message_content_test.h @@ -30,8 +30,6 @@ along with LOOT. If not, see #include "loot/metadata/message_content.h" namespace loot::test { -const std::string french = "fr"; - TEST(MessageContent, defaultConstructorShouldSetEmptyEnglishLanguageString) { MessageContent content; @@ -40,10 +38,10 @@ TEST(MessageContent, defaultConstructorShouldSetEmptyEnglishLanguageString) { } TEST(MessageContent, contentConstructorShouldStoreGivenStringAndLanguage) { - MessageContent content("content", french); + MessageContent content("content", "fr"); EXPECT_EQ("content", content.GetText()); - EXPECT_EQ(french, content.GetLanguage()); + EXPECT_EQ("fr", content.GetLanguage()); } TEST(MessageContent, diff --git a/cpp/src/tests/api/interface/metadata/message_test.h b/cpp/src/tests/api/interface/metadata/message_test.h index 844827fb..3cb0ff63 100644 --- a/cpp/src/tests/api/interface/metadata/message_test.h +++ b/cpp/src/tests/api/interface/metadata/message_test.h @@ -25,37 +25,32 @@ along with LOOT. If not, see #ifndef LOOT_TESTS_API_INTERFACE_METADATA_MESSAGE_TEST #define LOOT_TESTS_API_INTERFACE_METADATA_MESSAGE_TEST +#include + #include "loot/metadata/message.h" -#include "tests/common_game_test_fixture.h" namespace loot::test { -class MessageTest : public CommonGameTestFixture { -protected: - MessageTest() : CommonGameTestFixture(GameType::tes4) {} - typedef std::vector MessageContents; -}; - -TEST_F(MessageTest, defaultConstructorShouldCreateNoteWithNoContent) { +TEST(Message, defaultConstructorShouldCreateNoteWithNoContent) { Message message; EXPECT_EQ(MessageType::say, message.GetType()); - EXPECT_EQ(MessageContents(), message.GetContent()); + EXPECT_TRUE(message.GetContent().empty()); } -TEST_F(MessageTest, - scalarContentConstructorShouldCreateAMessageWithASingleContentString) { +TEST(Message, + scalarContentConstructorShouldCreateAMessageWithASingleContentString) { MessageContent content = MessageContent("content1"); Message message(MessageType::warn, content.GetText(), "condition1"); EXPECT_EQ(MessageType::warn, message.GetType()); - EXPECT_EQ(MessageContents({content}), message.GetContent()); + EXPECT_EQ(std::vector({content}), message.GetContent()); EXPECT_EQ("condition1", message.GetCondition()); } -TEST_F(MessageTest, - vectorContentConstructorShouldCreateAMessageWithGivenContentStrings) { - MessageContents contents({ +TEST(Message, + vectorContentConstructorShouldCreateAMessageWithGivenContentStrings) { + std::vector contents({ MessageContent("content1"), - MessageContent("content2", french), + MessageContent("content2", "fr"), }); Message message(MessageType::error, contents, "condition1"); @@ -64,18 +59,18 @@ TEST_F(MessageTest, EXPECT_EQ("condition1", message.GetCondition()); } -TEST_F( - MessageTest, +TEST( + Message, vectorContentConstructorShouldThrowIfMultipleContentStringsAreGivenAndNoneAreEnglish) { - MessageContents contents({ - MessageContent("content1", german), - MessageContent("content2", french), + std::vector contents({ + MessageContent("content1", "de"), + MessageContent("content2", "fr"), }); EXPECT_THROW(Message(MessageType::error, contents, "condition1"), std::invalid_argument); } -TEST_F(MessageTest, equalityShouldRequireEqualMessageTypes) { +TEST(Message, equalityShouldRequireEqualMessageTypes) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -87,7 +82,7 @@ TEST_F(MessageTest, equalityShouldRequireEqualMessageTypes) { EXPECT_FALSE(message1 == message2); } -TEST_F(MessageTest, equalityShouldRequireCaseSensitiveEqualityOnCondition) { +TEST(Message, equalityShouldRequireCaseSensitiveEqualityOnCondition) { Message message1(MessageType::say, "content", "condition"); Message message2(MessageType::say, "content", "condition"); @@ -104,7 +99,7 @@ TEST_F(MessageTest, equalityShouldRequireCaseSensitiveEqualityOnCondition) { EXPECT_FALSE(message1 == message2); } -TEST_F(MessageTest, equalityShouldRequireEqualContent) { +TEST(Message, equalityShouldRequireEqualContent) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -116,7 +111,7 @@ TEST_F(MessageTest, equalityShouldRequireEqualContent) { EXPECT_FALSE(message1 == message2); } -TEST_F(MessageTest, inequalityShouldBeTheInverseOfEquality) { +TEST(Message, inequalityShouldBeTheInverseOfEquality) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -153,7 +148,7 @@ TEST_F(MessageTest, inequalityShouldBeTheInverseOfEquality) { EXPECT_TRUE(message1 != message2); } -TEST_F(MessageTest, lessThanOperatorShouldCompareMessageTypes) { +TEST(Message, lessThanOperatorShouldCompareMessageTypes) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -167,7 +162,7 @@ TEST_F(MessageTest, lessThanOperatorShouldCompareMessageTypes) { EXPECT_FALSE(message2 < message1); } -TEST_F(MessageTest, lessThanOperatorShouldCompareContent) { +TEST(Message, lessThanOperatorShouldCompareContent) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -181,8 +176,8 @@ TEST_F(MessageTest, lessThanOperatorShouldCompareContent) { EXPECT_FALSE(message2 < message1); } -TEST_F( - MessageTest, +TEST( + Message, lessThanOperatorShouldUseCaseSensitiveLexicographicalComparisonForConditions) { Message message1(MessageType::say, "content", "condition"); Message message2(MessageType::say, "content", "condition"); @@ -203,9 +198,8 @@ TEST_F( EXPECT_FALSE(message2 < message1); } -TEST_F( - MessageTest, - greaterThanOperatorShouldReturnTrueIfTheSecondMessageIsLessThanTheFirst) { +TEST(Message, + greaterThanOperatorShouldReturnTrueIfTheSecondMessageIsLessThanTheFirst) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -249,8 +243,8 @@ TEST_F( EXPECT_TRUE(message2 > message1); } -TEST_F( - MessageTest, +TEST( + Message, lessThanOrEqualOperatorShouldReturnTrueIfTheFirstMessageIsNotGreaterThanTheSecond) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); @@ -295,8 +289,8 @@ TEST_F( EXPECT_FALSE(message2 <= message1); } -TEST_F( - MessageTest, +TEST( + Message, greaterThanOrEqualToOperatorShouldReturnTrueIfTheFirstMessageIsNotLessThanTheSecond) { Message message1(MessageType::say, "content"); Message message2(MessageType::say, "content"); diff --git a/cpp/src/tests/api/interface/metadata/plugin_cleaning_data_test.h b/cpp/src/tests/api/interface/metadata/plugin_cleaning_data_test.h index 49f30eb1..f07b80d7 100644 --- a/cpp/src/tests/api/interface/metadata/plugin_cleaning_data_test.h +++ b/cpp/src/tests/api/interface/metadata/plugin_cleaning_data_test.h @@ -25,450 +25,442 @@ along with LOOT. If not, see #ifndef LOOT_TESTS_API_INTERFACE_METADATA_PLUGIN_CLEANING_DATA_TEST #define LOOT_TESTS_API_INTERFACE_METADATA_PLUGIN_CLEANING_DATA_TEST +#include + #include "loot/metadata/plugin_cleaning_data.h" -#include "tests/common_game_test_fixture.h" namespace loot::test { -class PluginCleaningDataTest : public CommonGameTestFixture { -protected: - PluginCleaningDataTest() : - CommonGameTestFixture(GameType::tes4), - info_(std::vector({ - MessageContent("info"), - })) {} - - const std::vector info_; -}; - -TEST_F(PluginCleaningDataTest, - defaultConstructorShouldLeaveAllCountsAtZeroAndTheUtilityStringEmpty) { - PluginCleaningData info; - EXPECT_EQ(0u, info.GetCRC()); - EXPECT_EQ(0u, info.GetITMCount()); - EXPECT_EQ(0u, info.GetDeletedReferenceCount()); - EXPECT_EQ(0u, info.GetDeletedNavmeshCount()); - EXPECT_TRUE(info.GetCleaningUtility().empty()); - EXPECT_TRUE(info.GetDetail().empty()); - EXPECT_TRUE(info.GetCondition().empty()); +TEST(PluginCleaningData, + defaultConstructorShouldLeaveAllCountsAtZeroAndTheUtilityStringEmpty) { + PluginCleaningData data; + EXPECT_EQ(0u, data.GetCRC()); + EXPECT_EQ(0u, data.GetITMCount()); + EXPECT_EQ(0u, data.GetDeletedReferenceCount()); + EXPECT_EQ(0u, data.GetDeletedNavmeshCount()); + EXPECT_TRUE(data.GetCleaningUtility().empty()); + EXPECT_TRUE(data.GetDetail().empty()); + EXPECT_TRUE(data.GetCondition().empty()); } -TEST_F(PluginCleaningDataTest, contentConstructorShouldStoreAllGivenData) { - PluginCleaningData info(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_EQ(0x12345678u, info.GetCRC()); - EXPECT_EQ(2u, info.GetITMCount()); - EXPECT_EQ(10u, info.GetDeletedReferenceCount()); - EXPECT_EQ(30u, info.GetDeletedNavmeshCount()); - EXPECT_EQ("cleaner", info.GetCleaningUtility()); - EXPECT_EQ(info_, info.GetDetail()); - EXPECT_EQ("condition", info.GetCondition()); +TEST(PluginCleaningData, contentConstructorShouldStoreAllGivenData) { + const std::vector info{MessageContent("info")}; + + PluginCleaningData data(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_EQ(0x12345678u, data.GetCRC()); + EXPECT_EQ(2u, data.GetITMCount()); + EXPECT_EQ(10u, data.GetDeletedReferenceCount()); + EXPECT_EQ(30u, data.GetDeletedNavmeshCount()); + EXPECT_EQ("cleaner", data.GetCleaningUtility()); + EXPECT_EQ(info, data.GetDetail()); + EXPECT_EQ("condition", data.GetCondition()); } -TEST_F(PluginCleaningDataTest, equalityShouldCheckEqualityOfAllFields) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 == info2); +TEST(PluginCleaningData, equalityShouldCheckEqualityOfAllFields) { + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 == info2); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 == data2); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_FALSE(info1 == info2); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_FALSE(data1 == data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_FALSE(info1 == info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_FALSE(data1 == data2); } -TEST_F(PluginCleaningDataTest, inequalityShouldBeTheInverseOfEquality) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 != info2); +TEST(PluginCleaningData, inequalityShouldBeTheInverseOfEquality) { + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 != info2); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 != data2); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_TRUE(info1 != info2); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_TRUE(data1 != data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_TRUE(info1 != info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_TRUE(data1 != data2); } -TEST_F(PluginCleaningDataTest, lessThanOperatorShouldCompareAllFields) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 < info2); - EXPECT_FALSE(info2 < info1); +TEST(PluginCleaningData, lessThanOperatorShouldCompareAllFields) { + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 < info2); - EXPECT_FALSE(info2 < info1); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 < data2); + EXPECT_FALSE(data2 < data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info2 < info1); - EXPECT_FALSE(info1 < info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 < data2); + EXPECT_FALSE(data2 < data1); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 < info2); - EXPECT_FALSE(info2 < info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data2 < data1); + EXPECT_FALSE(data1 < data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 < data2); + EXPECT_FALSE(data2 < data1); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_TRUE(info2 < info1); - EXPECT_FALSE(info1 < info2); + EXPECT_TRUE(data2 < data1); + EXPECT_FALSE(data1 < data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_TRUE(info1 < info2); - EXPECT_FALSE(info2 < info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_TRUE(data1 < data2); + EXPECT_FALSE(data2 < data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_TRUE(info1 < info2); - EXPECT_FALSE(info2 < info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_TRUE(data1 < data2); + EXPECT_FALSE(data2 < data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_TRUE(info1 < info2); - EXPECT_FALSE(info2 < info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_TRUE(data1 < data2); + EXPECT_FALSE(data2 < data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_TRUE(info2 < info1); - EXPECT_FALSE(info1 < info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_TRUE(data2 < data1); + EXPECT_FALSE(data1 < data2); } -TEST_F( - PluginCleaningDataTest, +TEST( + PluginCleaningData, greaterThanOperatorShouldReturnTrueIfTheSecondPluginCleaningDataIsLessThanTheFirst) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_FALSE(info2 > info1); + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_TRUE(info2 > info1); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_FALSE(data2 > data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info2 > info1); - EXPECT_TRUE(info1 > info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_TRUE(data2 > data1); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_TRUE(info2 > info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data2 > data1); + EXPECT_TRUE(data1 > data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_TRUE(data2 > data1); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_FALSE(info2 > info1); - EXPECT_TRUE(info1 > info2); + EXPECT_FALSE(data2 > data1); + EXPECT_TRUE(data1 > data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_TRUE(info2 > info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_TRUE(data2 > data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_TRUE(info2 > info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_TRUE(data2 > data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_FALSE(info1 > info2); - EXPECT_TRUE(info2 > info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_FALSE(data1 > data2); + EXPECT_TRUE(data2 > data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_FALSE(info2 > info1); - EXPECT_TRUE(info1 > info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_FALSE(data2 > data1); + EXPECT_TRUE(data1 > data2); } -TEST_F( - PluginCleaningDataTest, +TEST( + PluginCleaningData, lessThanOrEqualOperatorShouldReturnTrueIfTheFirstPluginCleaningDataIsNotGreaterThanTheSecond) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_TRUE(info2 <= info1); + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_FALSE(info2 <= info1); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_TRUE(data2 <= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info2 <= info1); - EXPECT_FALSE(info1 <= info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_FALSE(data2 <= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_FALSE(info2 <= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data2 <= data1); + EXPECT_FALSE(data1 <= data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_FALSE(data2 <= data1); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_TRUE(info2 <= info1); - EXPECT_FALSE(info1 <= info2); + EXPECT_TRUE(data2 <= data1); + EXPECT_FALSE(data1 <= data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_FALSE(info2 <= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_FALSE(data2 <= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_FALSE(info2 <= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_FALSE(data2 <= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_TRUE(info1 <= info2); - EXPECT_FALSE(info2 <= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_TRUE(data1 <= data2); + EXPECT_FALSE(data2 <= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_TRUE(info2 <= info1); - EXPECT_FALSE(info1 <= info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_TRUE(data2 <= data1); + EXPECT_FALSE(data1 <= data2); } -TEST_F( - PluginCleaningDataTest, +TEST( + PluginCleaningData, greaterThanOrEqualToOperatorShouldReturnTrueIfTheFirstPluginCleaningDataIsNotLessThanTheSecond) { - PluginCleaningData info1( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - PluginCleaningData info2( - 0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_TRUE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + const std::vector info{MessageContent("info")}; - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x87654321, "cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + PluginCleaningData data1(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + PluginCleaningData data2(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_TRUE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "Cleaner", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info2 >= info1); - EXPECT_TRUE(info1 >= info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x87654321, "cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner1", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner2", info_, 2, 10, 30, "condition"); - EXPECT_FALSE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "Cleaner", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data2 >= data1); + EXPECT_TRUE(data1 >= data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = PluginCleaningData(0x12345678, + data1 = + PluginCleaningData(0x12345678, "cleaner1", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner2", info, 2, 10, 30, "condition"); + EXPECT_FALSE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); + + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = PluginCleaningData(0x12345678, "cleaner", std::vector(), 2, 10, 30, "condition"); - EXPECT_FALSE(info2 >= info1); - EXPECT_TRUE(info1 >= info2); + EXPECT_FALSE(data2 >= data1); + EXPECT_TRUE(data1 >= data2); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 4, 10, 30, "condition"); - EXPECT_FALSE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 4, 10, 30, "condition"); + EXPECT_FALSE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 20, 30, "condition"); - EXPECT_FALSE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 20, 30, "condition"); + EXPECT_FALSE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 60, "condition"); - EXPECT_FALSE(info1 >= info2); - EXPECT_TRUE(info2 >= info1); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 60, "condition"); + EXPECT_FALSE(data1 >= data2); + EXPECT_TRUE(data2 >= data1); - info1 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "condition"); - info2 = - PluginCleaningData(0x12345678, "cleaner", info_, 2, 10, 30, "Condition"); - EXPECT_FALSE(info2 >= info1); - EXPECT_TRUE(info1 >= info2); + data1 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "condition"); + data2 = + PluginCleaningData(0x12345678, "cleaner", info, 2, 10, 30, "Condition"); + EXPECT_FALSE(data2 >= data1); + EXPECT_TRUE(data1 >= data2); } } diff --git a/cpp/src/tests/api/interface/metadata/plugin_metadata_test.h b/cpp/src/tests/api/interface/metadata/plugin_metadata_test.h index 0f0f4dd8..19df6e1d 100644 --- a/cpp/src/tests/api/interface/metadata/plugin_metadata_test.h +++ b/cpp/src/tests/api/interface/metadata/plugin_metadata_test.h @@ -29,19 +29,8 @@ along with LOOT. If not, see #include "tests/common_game_test_fixture.h" namespace loot::test { -class PluginMetadataTest : public CommonGameTestFixture { -protected: - PluginMetadataTest() : - CommonGameTestFixture(GameType::tes5), - info_(std::vector({ - MessageContent("info"), - })) {} - - const std::vector info_; -}; - -TEST_F( - PluginMetadataTest, +TEST( + PluginMetadata, defaultConstructorShouldLeaveNameEmptyAndEnableMetadataAndLeaveGroupUnset) { PluginMetadata plugin; @@ -49,50 +38,49 @@ TEST_F( EXPECT_FALSE(plugin.GetGroup()); } -TEST_F( - PluginMetadataTest, +TEST( + PluginMetadata, stringConstructorShouldSetNameToGivenStringAndEnableMetadataAndLeaveGroupUnset) { - PluginMetadata plugin(blankEsm); + PluginMetadata plugin(BLANK_ESM); - EXPECT_EQ(blankEsm, plugin.GetName()); + EXPECT_EQ(BLANK_ESM, plugin.GetName()); EXPECT_FALSE(plugin.GetGroup()); } -TEST_F(PluginMetadataTest, - nameMatchesShouldUseCaseInsensitiveNameComparisonForNonRegexNames) { - PluginMetadata plugin(blankEsm); +TEST(PluginMetadata, + nameMatchesShouldUseCaseInsensitiveNameComparisonForNonRegexNames) { + PluginMetadata plugin(BLANK_ESM); EXPECT_TRUE(plugin.NameMatches("blank.esm")); - EXPECT_FALSE(plugin.NameMatches(blankDifferentEsm)); + EXPECT_FALSE(plugin.NameMatches(BLANK_DIFFERENT_ESM)); } -TEST_F(PluginMetadataTest, - nameMatchesShouldTreatGivenPluginNameStringsAsLiterals) { - PluginMetadata plugin(blankEsm); +TEST(PluginMetadata, nameMatchesShouldTreatGivenPluginNameStringsAsLiterals) { + PluginMetadata plugin(BLANK_ESM); std::string regex = "blan.\\.esm"; EXPECT_FALSE(plugin.NameMatches(regex)); } -TEST_F(PluginMetadataTest, - nameMatchesShouldUseCaseInsensitiveRegexMatchingForARegexName) { +TEST(PluginMetadata, + nameMatchesShouldUseCaseInsensitiveRegexMatchingForARegexName) { PluginMetadata plugin("Blan.\\.esm"); EXPECT_TRUE(plugin.NameMatches("blank.esm")); - EXPECT_FALSE(plugin.NameMatches(blankDifferentEsm)); + EXPECT_FALSE(plugin.NameMatches(BLANK_DIFFERENT_ESM)); } -TEST_F(PluginMetadataTest, mergeMetadataShouldNotChangeName) { - PluginMetadata plugin1(blankEsm); - PluginMetadata plugin2(blankDifferentEsm); +TEST(PluginMetadata, mergeMetadataShouldNotChangeName) { + PluginMetadata plugin1(BLANK_ESM); + PluginMetadata plugin2(BLANK_DIFFERENT_ESM); plugin1.MergeMetadata(plugin2); - EXPECT_EQ(blankEsm, plugin1.GetName()); + EXPECT_EQ(BLANK_ESM, plugin1.GetName()); } -TEST_F(PluginMetadataTest, - mergeMetadataShouldNotUseMergedGroupIfItAndCurrentGroupAreBothExplicit) { +TEST(PluginMetadata, + mergeMetadataShouldNotUseMergedGroupIfItAndCurrentGroupAreBothExplicit) { PluginMetadata plugin1; PluginMetadata plugin2; @@ -103,8 +91,8 @@ TEST_F(PluginMetadataTest, EXPECT_EQ("group1", plugin1.GetGroup()); } -TEST_F(PluginMetadataTest, - mergeMetadataShouldNotUseMergedGroupIfItAndCurrentGroupAreBothImplicit) { +TEST(PluginMetadata, + mergeMetadataShouldNotUseMergedGroupIfItAndCurrentGroupAreBothImplicit) { PluginMetadata plugin1; PluginMetadata plugin2; @@ -113,8 +101,8 @@ TEST_F(PluginMetadataTest, EXPECT_FALSE(plugin1.GetGroup().has_value()); } -TEST_F( - PluginMetadataTest, +TEST( + PluginMetadata, mergeMetadataShouldNotUseMergedGroupIfItIsImplicitAndCurrentGroupIsExplicit) { PluginMetadata plugin1; PluginMetadata plugin2; @@ -125,9 +113,8 @@ TEST_F( EXPECT_EQ("group1", plugin1.GetGroup()); } -TEST_F( - PluginMetadataTest, - mergeMetadataShouldUseMergedGroupIfItIsExplicitAndCurrentGroupIsImplicit) { +TEST(PluginMetadata, + mergeMetadataShouldUseMergedGroupIfItIsExplicitAndCurrentGroupIsImplicit) { PluginMetadata plugin1; PluginMetadata plugin2; @@ -137,11 +124,11 @@ TEST_F( EXPECT_EQ("group2", plugin1.GetGroup()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeLoadAfterData) { +TEST(PluginMetadata, mergeMetadataShouldMergeLoadAfterData) { PluginMetadata plugin1; PluginMetadata plugin2; - File file1(blankEsm); - File file2(blankDifferentEsm); + File file1(BLANK_ESM); + File file2(BLANK_DIFFERENT_ESM); plugin1.SetLoadAfterFiles({file1}); plugin2.SetLoadAfterFiles({file1, file2}); @@ -150,11 +137,11 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeLoadAfterData) { EXPECT_EQ(std::vector({file1, file2}), plugin1.GetLoadAfterFiles()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeRequirementData) { +TEST(PluginMetadata, mergeMetadataShouldMergeRequirementData) { PluginMetadata plugin1; PluginMetadata plugin2; - File file1(blankEsm); - File file2(blankDifferentEsm); + File file1(BLANK_ESM); + File file2(BLANK_DIFFERENT_ESM); plugin1.SetRequirements({file1}); plugin2.SetRequirements({file1, file2}); @@ -163,11 +150,11 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeRequirementData) { EXPECT_EQ(std::vector({file1, file2}), plugin1.GetRequirements()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeIncompatibilityData) { +TEST(PluginMetadata, mergeMetadataShouldMergeIncompatibilityData) { PluginMetadata plugin1; PluginMetadata plugin2; - File file1(blankEsm); - File file2(blankDifferentEsm); + File file1(BLANK_ESM); + File file2(BLANK_DIFFERENT_ESM); plugin1.SetIncompatibilities({file1}); plugin2.SetIncompatibilities({file1, file2}); @@ -176,7 +163,7 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeIncompatibilityData) { EXPECT_EQ(std::vector({file1, file2}), plugin1.GetIncompatibilities()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeMessages) { +TEST(PluginMetadata, mergeMetadataShouldMergeMessages) { PluginMetadata plugin1; PluginMetadata plugin2; Message message(MessageType::say, "content"); @@ -188,7 +175,7 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeMessages) { EXPECT_EQ(std::vector({message, message}), plugin1.GetMessages()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeTags) { +TEST(PluginMetadata, mergeMetadataShouldMergeTags) { PluginMetadata plugin1; PluginMetadata plugin2; Tag tag1("Relev"); @@ -202,11 +189,13 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeTags) { EXPECT_EQ(std::vector({tag1, tag2, tag3}), plugin1.GetTags()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeDirtyInfoData) { +TEST(PluginMetadata, mergeMetadataShouldMergeDirtyInfoData) { PluginMetadata plugin1; PluginMetadata plugin2; - PluginCleaningData info1(0x5, "utility", info_, 1, 2, 3, "condition"); - PluginCleaningData info2(0xA, "utility", info_, 1, 2, 3, "condition"); + PluginCleaningData info1( + 0x5, "utility", {MessageContent("info")}, 1, 2, 3, "condition"); + PluginCleaningData info2( + 0xA, "utility", {MessageContent("info")}, 1, 2, 3, "condition"); plugin1.SetDirtyInfo({info1}); plugin2.SetDirtyInfo({info1, info2}); @@ -215,7 +204,7 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeDirtyInfoData) { EXPECT_EQ(std::vector({info1, info2}), plugin1.GetDirtyInfo()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeCleanInfoData) { +TEST(PluginMetadata, mergeMetadataShouldMergeCleanInfoData) { PluginMetadata plugin1; PluginMetadata plugin2; PluginCleaningData info1(0x5, "utility"); @@ -229,7 +218,7 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeCleanInfoData) { plugin1.GetCleanInfo()); } -TEST_F(PluginMetadataTest, mergeMetadataShouldMergeLocationData) { +TEST(PluginMetadata, mergeMetadataShouldMergeLocationData) { PluginMetadata plugin1; PluginMetadata plugin2; Location location1("http://www.example.com/1"); @@ -243,7 +232,7 @@ TEST_F(PluginMetadataTest, mergeMetadataShouldMergeLocationData) { plugin1.GetLocations()); } -TEST_F(PluginMetadataTest, unsetGroupShouldLeaveNoGroupValueSet) { +TEST(PluginMetadata, unsetGroupShouldLeaveNoGroupValueSet) { PluginMetadata plugin; EXPECT_FALSE(plugin.GetGroup().has_value()); @@ -254,137 +243,134 @@ TEST_F(PluginMetadataTest, unsetGroupShouldLeaveNoGroupValueSet) { EXPECT_FALSE(plugin.GetGroup().has_value()); } -TEST_F(PluginMetadataTest, - hasNameOnlyShouldBeTrueForADefaultConstructedPluginMetadataObject) { +TEST(PluginMetadata, + hasNameOnlyShouldBeTrueForADefaultConstructedPluginMetadataObject) { PluginMetadata plugin; EXPECT_TRUE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, - hasNameOnlyShouldBeTrueForAPluginMetadataObjectConstructedWithAName) { - PluginMetadata plugin(blankEsp); +TEST(PluginMetadata, + hasNameOnlyShouldBeTrueForAPluginMetadataObjectConstructedWithAName) { + PluginMetadata plugin(BLANK_ESP); EXPECT_TRUE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfTheGroupIsExplicit) { +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfTheGroupIsExplicit) { PluginMetadata plugin; plugin.SetGroup("group"); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfLoadAfterMetadataExists) { - PluginMetadata plugin(blankEsp); - plugin.SetLoadAfterFiles({File(blankEsm)}); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfLoadAfterMetadataExists) { + PluginMetadata plugin(BLANK_ESP); + plugin.SetLoadAfterFiles({File(BLANK_ESM)}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, - hasNameOnlyShouldBeFalseIfRequirementMetadataExists) { - PluginMetadata plugin(blankEsp); - plugin.SetRequirements({File(blankEsm)}); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfRequirementMetadataExists) { + PluginMetadata plugin(BLANK_ESP); + plugin.SetRequirements({File(BLANK_ESM)}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, - hasNameOnlyShouldBeFalseIfIncompatibilityMetadataExists) { - PluginMetadata plugin(blankEsp); - plugin.SetIncompatibilities({File(blankEsm)}); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfIncompatibilityMetadataExists) { + PluginMetadata plugin(BLANK_ESP); + plugin.SetIncompatibilities({File(BLANK_ESM)}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfMessagesExist) { - PluginMetadata plugin(blankEsp); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfMessagesExist) { + PluginMetadata plugin(BLANK_ESP); plugin.SetMessages({Message(MessageType::say, "content")}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfTagsExist) { - PluginMetadata plugin(blankEsp); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfTagsExist) { + PluginMetadata plugin(BLANK_ESP); plugin.SetTags({Tag("Relev")}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfDirtyInfoExists) { - PluginMetadata plugin(blankEsp); - plugin.SetDirtyInfo( - {PluginCleaningData(5, "utility", info_, 0, 1, 2, "condition")}); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfDirtyInfoExists) { + PluginMetadata plugin(BLANK_ESP); + plugin.SetDirtyInfo({PluginCleaningData( + 5, "utility", {MessageContent("info")}, 0, 1, 2, "condition")}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfCleanInfoExists) { - PluginMetadata plugin(blankEsp); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfCleanInfoExists) { + PluginMetadata plugin(BLANK_ESP); plugin.SetCleanInfo({PluginCleaningData(5, "utility")}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, hasNameOnlyShouldBeFalseIfLocationsExist) { - PluginMetadata plugin(blankEsp); +TEST(PluginMetadata, hasNameOnlyShouldBeFalseIfLocationsExist) { + PluginMetadata plugin(BLANK_ESP); plugin.SetLocations({Location("http://www.example.com")}); EXPECT_FALSE(plugin.HasNameOnly()); } -TEST_F(PluginMetadataTest, isRegexPluginShouldBeFalseForAnEmptyPluginName) { +TEST(PluginMetadata, isRegexPluginShouldBeFalseForAnEmptyPluginName) { PluginMetadata plugin; EXPECT_FALSE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, isRegexPluginShouldBeFalseForAnExactPluginFilename) { - PluginMetadata plugin(blankEsm); +TEST(PluginMetadata, isRegexPluginShouldBeFalseForAnExactPluginFilename) { + PluginMetadata plugin(BLANK_ESM); EXPECT_FALSE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - isRegexPluginShouldBeTrueIfThePluginNameContainsAColon) { +TEST(PluginMetadata, isRegexPluginShouldBeTrueIfThePluginNameContainsAColon) { PluginMetadata plugin("Blank:.esm"); EXPECT_TRUE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - isRegexPluginShouldBeTrueIfThePluginNameContainsABackslash) { +TEST(PluginMetadata, + isRegexPluginShouldBeTrueIfThePluginNameContainsABackslash) { PluginMetadata plugin("Blank\\.esm"); EXPECT_TRUE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - isRegexPluginShouldBeTrueIfThePluginNameContainsAnAsterisk) { +TEST(PluginMetadata, + isRegexPluginShouldBeTrueIfThePluginNameContainsAnAsterisk) { PluginMetadata plugin("Blank*.esm"); EXPECT_TRUE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - isRegexPluginShouldBeTrueIfThePluginNameContainsAQuestionMark) { +TEST(PluginMetadata, + isRegexPluginShouldBeTrueIfThePluginNameContainsAQuestionMark) { PluginMetadata plugin("Blank?.esm"); EXPECT_TRUE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - isRegexPluginShouldBeTrueIfThePluginNameContainsAVerticalBar) { +TEST(PluginMetadata, + isRegexPluginShouldBeTrueIfThePluginNameContainsAVerticalBar) { PluginMetadata plugin("Blank|.esm"); EXPECT_TRUE(plugin.IsRegexPlugin()); } -TEST_F(PluginMetadataTest, - asYamlShouldReturnAStringContainingTheMetadataEmittedAsYaml) { - PluginMetadata plugin(blankEsm); - plugin.SetLoadAfterFiles({File(blankEsm)}); +TEST(PluginMetadata, + asYamlShouldReturnAStringContainingTheMetadataEmittedAsYaml) { + PluginMetadata plugin(BLANK_ESM); + plugin.SetLoadAfterFiles({File(BLANK_ESM)}); EXPECT_EQ( "name: 'Blank.esm'\n" diff --git a/cpp/src/tests/common_game_test_fixture.h b/cpp/src/tests/common_game_test_fixture.h index 84a8ad91..25d347cc 100644 --- a/cpp/src/tests/common_game_test_fixture.h +++ b/cpp/src/tests/common_game_test_fixture.h @@ -54,38 +54,61 @@ static const std::array ALL_GAME_TYPES = { GameType::oblivionRemastered, }; +inline constexpr std::string_view FRENCH = "fr"; +inline constexpr std::string_view GERMAN = "de"; + +inline constexpr std::string_view MISSING_ESP = "Blank.missing.esp"; +inline constexpr std::string_view NON_PLUGIN_FILE = "NotAPlugin.esm"; +inline constexpr std::string_view INVALID_PLUGIN = "Invalid.esm"; +inline constexpr std::string_view BLANK_ESM = "Blank.esm"; +inline constexpr std::string_view BLANK_FULL_ESM = "Blank.full.esm"; +inline constexpr std::string_view BLANK_MEDIUM_ESM = "Blank.medium.esm"; +inline constexpr std::string_view BLANK_DIFFERENT_ESM = "Blank - Different.esm"; +inline constexpr std::string_view BLANK_MASTER_DEPENDENT_ESM = + "Blank - Master Dependent.esm"; +inline constexpr std::string_view BLANK_DIFFERENT_MASTER_DEPENDENT_ESM = + "Blank - Different Master Dependent.esm"; +inline constexpr std::string_view BLANK_ESL = "Blank.esl"; +inline constexpr std::string_view BLANK_ESP = "Blank.esp"; +inline constexpr std::string_view BLANK_DIFFERENT_ESP = "Blank - Different.esp"; +inline constexpr std::string_view BLANK_MASTER_DEPENDENT_ESP = + "Blank - Master Dependent.esp"; +inline constexpr std::string_view BLANK_DIFFERENT_MASTER_DEPENDENT_ESP = + "Blank - Different Master Dependent.esp"; +inline constexpr std::string_view BLANK_PLUGIN_DEPENDENT_ESP = + "Blank - Plugin Dependent.esp"; +inline constexpr std::string_view BLANK_DIFFERENT_PLUGIN_DEPENDENT_ESP = + "Blank - Different Plugin Dependent.esp"; + class CommonGameTestFixture : public ::testing::Test { protected: CommonGameTestFixture(GameType gameType) : gameType_(gameType), rootTestPath(getRootTestPath()), - french("fr"), - german("de"), + french(FRENCH), + german(GERMAN), missingPath(rootTestPath / "missing"), gamePath(rootTestPath / "games" / "game"), dataPath(gamePath / getPluginsFolder()), localPath(rootTestPath / "local" / "game"), metadataFilesPath(rootTestPath / "metadata"), masterFile(getMasterFile()), - missingEsp("Blank.missing.esp"), - nonPluginFile("NotAPlugin.esm"), - invalidPlugin("Invalid.esm"), - blankEsm("Blank.esm"), - blankFullEsm("Blank.full.esm"), - blankMediumEsm("Blank.medium.esm"), - blankDifferentEsm("Blank - Different.esm"), - blankMasterDependentEsm("Blank - Master Dependent.esm"), - blankDifferentMasterDependentEsm( - "Blank - Different Master Dependent.esm"), - blankEsl("Blank.esl"), - blankEsp("Blank.esp"), - blankDifferentEsp("Blank - Different.esp"), - blankMasterDependentEsp("Blank - Master Dependent.esp"), - blankDifferentMasterDependentEsp( - "Blank - Different Master Dependent.esp"), - blankPluginDependentEsp("Blank - Plugin Dependent.esp"), - blankDifferentPluginDependentEsp( - "Blank - Different Plugin Dependent.esp"), + missingEsp(MISSING_ESP), + nonPluginFile(NON_PLUGIN_FILE), + invalidPlugin(INVALID_PLUGIN), + blankEsm(BLANK_ESM), + blankFullEsm(BLANK_FULL_ESM), + blankMediumEsm(BLANK_MEDIUM_ESM), + blankDifferentEsm(BLANK_DIFFERENT_ESM), + blankMasterDependentEsm(BLANK_MASTER_DEPENDENT_ESM), + blankDifferentMasterDependentEsm(BLANK_DIFFERENT_MASTER_DEPENDENT_ESM), + blankEsl(BLANK_ESL), + blankEsp(BLANK_ESP), + blankDifferentEsp(BLANK_DIFFERENT_ESP), + blankMasterDependentEsp(BLANK_MASTER_DEPENDENT_ESP), + blankDifferentMasterDependentEsp(BLANK_DIFFERENT_MASTER_DEPENDENT_ESP), + blankPluginDependentEsp(BLANK_PLUGIN_DEPENDENT_ESP), + blankDifferentPluginDependentEsp(BLANK_DIFFERENT_PLUGIN_DEPENDENT_ESP), blankEsmCrc(getBlankEsmCrc()) { assertInitialState(); }