kierankihn/uno-game
1
0
Fork 0
mirror of https://github.com/kierankihn/uno-game.git synced 2025-12-27 02:13:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: update assertions to use player ID and standardize card serialization format

Browse Source
This commit is contained in:
Kieran Kihn
2025-12-10 21:45:44 +08:00
parent fb9f308635
commit a161b55f35
3 changed files with 79 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
test/unit/game/CardTest.cpp
View File

@@ -5,8 +5,8 @@
* @date 2025.11.15
*/
#include "gtest/gtest.h"
#include "../../../src/game/Card.h"
#include "gtest/gtest.h"
TEST(card_test, card_test_1)
{
@@ -14,9 +14,9 @@ TEST(card_test, card_test_1)
EXPECT_EQ(card.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::NUM0);
EXPECT_EQ(card.colorToString(), std::string("Red"));
EXPECT_EQ(card.colorToString(), std::string("red"));
EXPECT_EQ(card.typeToString(), std::string("0"));
EXPECT_EQ(card.toString(), std::string("Red 0"));
EXPECT_EQ(card.toString(), std::string("red_0"));
}
TEST(card_test, card_test_2)
@@ -25,9 +25,9 @@ TEST(card_test, card_test_2)
EXPECT_EQ(card.getColor(), UNO::GAME::CardColor::BLUE);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::REVERSE);
EXPECT_EQ(card.colorToString(), std::string("Blue"));
EXPECT_EQ(card.typeToString(), std::string("Reverse"));
EXPECT_EQ(card.toString(), std::string("Blue Reverse"));
EXPECT_EQ(card.colorToString(), std::string("blue"));
EXPECT_EQ(card.typeToString(), std::string("reverse"));
EXPECT_EQ(card.toString(), std::string("blue_reverse"));
}
TEST(card_test, card_test_3)
@@ -36,9 +36,9 @@ TEST(card_test, card_test_3)
EXPECT_EQ(card.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILD);
EXPECT_EQ(card.colorToString(), std::string("Red"));
EXPECT_EQ(card.typeToString(), std::string("Wild"));
EXPECT_EQ(card.toString(), std::string("Wild"));
EXPECT_EQ(card.colorToString(), std::string("red"));
EXPECT_EQ(card.typeToString(), std::string("wild_wild"));
EXPECT_EQ(card.toString(), std::string("wild_wild"));
}
TEST(card_test, card_test_4)
@@ -47,7 +47,7 @@ TEST(card_test, card_test_4)
EXPECT_EQ(card.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILDDRAWFOUR);
EXPECT_EQ(card.colorToString(), std::string("Red"));
EXPECT_EQ(card.typeToString(), std::string("Wild Draw 4"));
EXPECT_EQ(card.toString(), std::string("Wild Draw 4"));
EXPECT_EQ(card.colorToString(), std::string("red"));
EXPECT_EQ(card.typeToString(), std::string("wild_draw_four"));
EXPECT_EQ(card.toString(), std::string("wild_draw_four"));
}

65
test/unit/game/GameStateTest.cpp
View File

@@ -28,67 +28,67 @@ TEST(game_state_test, game_state_test_1)
ASSERT_EQ(players[2].getName(), "qkp");
ASSERT_EQ(players[3].getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::REVERSE));
ASSERT_EQ(clientGameState.getIsReversed(), true);
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::SKIP));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::DRAW2));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
ASSERT_EQ(clientGameState.getDrawCount(), 2);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::DRAW2));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
ASSERT_EQ(clientGameState.getDrawCount(), 4);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
ASSERT_EQ(clientGameState.getDrawCount(), 8);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
ASSERT_EQ(clientGameState.getDrawCount(), 12);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
ASSERT_EQ(clientGameState.getDrawCount(), 16);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR));
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
ASSERT_EQ(clientGameState.getDrawCount(), 20);
clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getPlayers()[3].getName(), "lzh");
ASSERT_EQ(clientGameState.getPlayers()[3].getRemainingCardCount(), 120);
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp");
ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
ASSERT_EQ(clientGameState.getDrawCount(), 0);
}
@@ -108,11 +108,11 @@ TEST(game_state_test, game_state_test_2)
}
while (true) {
for (auto it = serverGameState.getCurrentPlayer()->getCards().begin();; it++) {
const auto player = serverGameState.getCurrentPlayer();
auto prevCards = player->getCards();
if (it == serverGameState.getCurrentPlayer()->getCards().end()) {
size_t prevCount = player->getRemainingCardCount();
for (auto it = serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getCards().begin();; it++) {
const auto &player = serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()];
auto prevCards = player.getCards();
if (it == serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getCards().end()) {
size_t prevCount = player.getRemainingCardCount();
size_t drawCount = serverGameState.getDrawCount();
if (drawCount == 0) {
drawCount = 1;
@@ -120,11 +120,11 @@ TEST(game_state_test, game_state_test_2)
serverGameState.updateStateByDraw();
size_t afterCount = player->getRemainingCardCount();
size_t afterCount = player.getRemainingCardCount();
ASSERT_EQ(prevCount + drawCount, afterCount);
for (auto card : prevCards) {
ASSERT_LE(prevCards.count(card), player->getCards().count(card));
ASSERT_LE(prevCards.count(card), player.getCards().count(card));
}
break;
@@ -132,17 +132,17 @@ TEST(game_state_test, game_state_test_2)
if (it->canBePlayedOn(serverGameState.getDiscardPile().getFront(), serverGameState.getDrawCount())) {
auto card = *it;
size_t prevCount = player->getCards().count(card);
size_t prevCount = player.getCards().count(card);
serverGameState.updateStateByCard(card);
size_t afterCount = player->getCards().count(card);
size_t afterCount = player.getCards().count(card);
ASSERT_EQ(prevCount - 1, afterCount);
ASSERT_EQ(prevCards.size() - 1, player->getCards().size());
ASSERT_EQ(prevCards.size() - 1, player.getCards().size());
for (auto i : player->getCards()) {
for (auto i : player.getCards()) {
if (i.getType() != card.getType() || i.getColor() != card.getColor()) {
ASSERT_EQ(player->getCards().count(i), prevCards.count(i));
ASSERT_EQ(player.getCards().count(i), prevCards.count(i));
}
}
@@ -150,9 +150,10 @@ TEST(game_state_test, game_state_test_2)
}
}
ASSERT_EQ(serverGameState.getCurrentPlayer()->getRemainingCardCount(), serverGameState.getCurrentPlayer()->getCards().size());
ASSERT_EQ(serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getRemainingCardCount(),
serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getCards().size());
if (serverGameState.getCurrentPlayer()->getRemainingCardCount() == 0) {
if (serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getRemainingCardCount() == 0) {
break;
}
}

66
test/unit/network/MessageSerializerTest.cpp
View File

@@ -81,10 +81,10 @@ TEST(MessageSerializerTest, SerializeDrawCardMessage)
EXPECT_EQ(json["payload"]["draw_count"], 5);
EXPECT_TRUE(json["payload"]["cards"].is_array());
EXPECT_EQ(json["payload"]["cards"].size(), 2);
EXPECT_EQ(json["payload"]["cards"][0]["card_color"], "Red");
EXPECT_EQ(json["payload"]["cards"][0]["card_color"], "red");
EXPECT_EQ(json["payload"]["cards"][0]["card_type"], "5");
EXPECT_EQ(json["payload"]["cards"][1]["card_color"], "Blue");
EXPECT_EQ(json["payload"]["cards"][1]["card_type"], "Skip");
EXPECT_EQ(json["payload"]["cards"][1]["card_color"], "blue");
EXPECT_EQ(json["payload"]["cards"][1]["card_type"], "skip");
}
TEST(MessageSerializerTest, SerializeDrawCardMessageWithZero)
@@ -132,14 +132,14 @@ TEST(MessageSerializerTest, SerializePlayCardMessage)
EXPECT_EQ(json["status_code"], "OK");
EXPECT_EQ(json["payload_type"], "PLAY_CARD");
EXPECT_EQ(json["payload"]["card"]["card_color"], "Red");
EXPECT_EQ(json["payload"]["card"]["card_color"], "red");
EXPECT_EQ(json["payload"]["card"]["card_type"], "5");
}
TEST(MessageSerializerTest, SerializePlayCardMessageAllColors)
{
std::vector<std::pair<CardColor, std::string>> colors = {
{CardColor::RED, "Red"}, {CardColor::BLUE, "Blue"}, {CardColor::GREEN, "Green"}, {CardColor::YELLOW, "Yellow"}};
{CardColor::RED, "red"}, {CardColor::BLUE, "blue"}, {CardColor::GREEN, "green"}, {CardColor::YELLOW, "yellow"}};
for (const auto &[color, expected] : colors) {
Card card(color, CardType::NUM1);
@@ -166,11 +166,11 @@ TEST(MessageSerializerTest, SerializePlayCardMessageAllTypes)
{CardType::NUM7, "7"},
{CardType::NUM8, "8"},
{CardType::NUM9, "9"},
{CardType::SKIP, "Skip"},
{CardType::REVERSE, "Reverse"},
{CardType::DRAW2, "Draw 2"},
{CardType::WILD, "Wild"},
{CardType::WILDDRAWFOUR, "Wild Draw 4"}};
{CardType::SKIP, "skip"},
{CardType::REVERSE, "reverse"},
{CardType::DRAW2, "draw_two"},
{CardType::WILD, "wild_wild"},
{CardType::WILDDRAWFOUR, "wild_draw_four"}};
for (const auto &[type, expected] : types) {
Card card(CardColor::RED, type);
@@ -341,7 +341,7 @@ TEST(MessageSerializerTest, DeserializeStartGameMessage)
TEST(MessageSerializerTest, DeserializeDrawCardMessage)
{
std::string json =
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":5,"cards":[{"card_color":"Red","card_type":"5"},{"card_color":"Blue","card_type":"Skip"}]}})";
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":5,"cards":[{"card_color":"red","card_type":"5"},{"card_color":"blue","card_type":"skip"}]}})";
Message message = MessageSerializer::deserialize(json);
@@ -371,7 +371,7 @@ TEST(MessageSerializerTest, DeserializeDrawCardMessageWithEmptyCards)
TEST(MessageSerializerTest, DeserializePlayCardMessage)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":"5"}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":"5"}}})";
Message message = MessageSerializer::deserialize(json);
@@ -390,8 +390,8 @@ TEST(MessageSerializerTest, DeserializeInitGameMessage)
"payload":{
"player_id":42,
"players": [],
"discard_pile":[{"card_color":"Red","card_type":"5"}],
"hand_card":[{"card_color":"Blue","card_type":"Skip"}],
"discard_pile":[{"card_color":"red","card_type":"5"}],
"hand_card":[{"card_color":"blue","card_type":"skip"}],
"current_player":2
}
})";
@@ -725,7 +725,7 @@ TEST(MessageSerializerTest, DeserializeDrawCardWithStringCards)
TEST(MessageSerializerTest, DeserializeDrawCardWithInvalidCardInArray)
{
std::string json =
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":2,"cards":[{"card_color":"Red","card_type":"5"},"invalid"]}})";
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":2,"cards":[{"card_color":"red","card_type":"5"},"invalid"]}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -739,7 +739,7 @@ TEST(MessageSerializerTest, DeserializeDrawCardWithInvalidCardColor)
TEST(MessageSerializerTest, DeserializeDrawCardWithInvalidCardType)
{
std::string json =
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":1,"cards":[{"card_color":"Red","card_type":"Invalid"}]}})";
R"({"status_code":"OK","payload_type":"DRAW_CARD","payload":{"draw_count":1,"cards":[{"card_color":"red","card_type":"Invalid"}]}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -777,7 +777,7 @@ TEST(MessageSerializerTest, DeserializePlayCardWithArrayCard)
TEST(MessageSerializerTest, DeserializePlayCardWithStringCard)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":"Red 5"}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":"red 5"}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -789,7 +789,7 @@ TEST(MessageSerializerTest, DeserializePlayCardWithMissingCardColor)
TEST(MessageSerializerTest, DeserializePlayCardWithMissingCardType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red"}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red"}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -801,7 +801,7 @@ TEST(MessageSerializerTest, DeserializePlayCardWithInvalidCardColor)
TEST(MessageSerializerTest, DeserializePlayCardWithInvalidCardType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":"Invalid"}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":"Invalid"}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -813,7 +813,7 @@ TEST(MessageSerializerTest, DeserializePlayCardWithNumberCardColor)
TEST(MessageSerializerTest, DeserializePlayCardWithNumberCardType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":5}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":5}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -825,7 +825,7 @@ TEST(MessageSerializerTest, DeserializePlayCardWithNullCardColor)
TEST(MessageSerializerTest, DeserializePlayCardWithNullCardType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":null}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":null}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -837,19 +837,19 @@ TEST(MessageSerializerTest, DeserializePlayCardWithEmptyCardColor)
TEST(MessageSerializerTest, DeserializePlayCardWithEmptyCardType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":""}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":""}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
TEST(MessageSerializerTest, DeserializePlayCardWithCaseSensitiveColor)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":"5"}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":"5"}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
TEST(MessageSerializerTest, DeserializePlayCardWithCaseSensitiveType)
{
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"Red","card_type":"skip"}}})";
std::string json = R"({"status_code":"OK","payload_type":"PLAY_CARD","payload":{"card":{"card_color":"red","card_type":"Skip"}}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -989,7 +989,7 @@ TEST(MessageSerializerTest, DeserializeInitGameWithInvalidCardInDiscardPile)
TEST(MessageSerializerTest, DeserializeInitGameWithInvalidCardInHandCard)
{
std::string json =
R"({"status_code":"OK","payload_type":"INIT_GAME","payload":{"player_id":0,"discard_pile":[],"hand_card":[{"card_color":"Red","card_type":"Invalid"}],"current_player":0,"players": []}})";
R"({"status_code":"OK","payload_type":"INIT_GAME","payload":{"player_id":0,"discard_pile":[],"hand_card":[{"card_color":"red","card_type":"Invalid"}],"current_player":0,"players": []}})";
EXPECT_THROW(MessageSerializer::deserialize(json), std::invalid_argument);
}
@@ -1102,7 +1102,7 @@ TEST(MessageSerializerTest, DeserializeCompactJSON)
TEST(MessageSerializerTest, DeserializeAllCardColors)
{
std::vector<std::pair<std::string, CardColor>> colors = {
{"Red", CardColor::RED}, {"Blue", CardColor::BLUE}, {"Green", CardColor::GREEN}, {"Yellow", CardColor::YELLOW}};
{"red", CardColor::RED}, {"blue", CardColor::BLUE}, {"green", CardColor::GREEN}, {"yellow", CardColor::YELLOW}};
for (const auto &[colorStr, colorEnum] : colors) {
nlohmann::json json = {
@@ -1125,15 +1125,15 @@ TEST(MessageSerializerTest, DeserializeAllCardTypes)
{"7", CardType::NUM7},
{"8", CardType::NUM8},
{"9", CardType::NUM9},
{"Skip", CardType::SKIP},
{"Reverse", CardType::REVERSE},
{"Draw 2", CardType::DRAW2},
{"Wild", CardType::WILD},
{"Wild Draw 4", CardType::WILDDRAWFOUR}};
{"skip", CardType::SKIP},
{"reverse", CardType::REVERSE},
{"draw_two", CardType::DRAW2},
{"wild_wild", CardType::WILD},
{"wild_draw_four", CardType::WILDDRAWFOUR}};
for (const auto &[typeStr, typeEnum] : types) {
nlohmann::json json = {
{"status_code", "OK"}, {"payload_type", "PLAY_CARD"}, {"payload", {{"card", {{"card_color", "Red"}, {"card_type", typeStr}}}}}};
{"status_code", "OK"}, {"payload_type", "PLAY_CARD"}, {"payload", {{"card", {{"card_color", "red"}, {"card_type", typeStr}}}}}};
Message message = MessageSerializer::deserialize(json.dump());
auto payload = std::get<PlayCardPayload>(message.getMessagePayload());
EXPECT_EQ(payload.card.getType(), typeEnum);
@@ -1162,7 +1162,7 @@ TEST(MessageSerializerTest, DeserializeHugeArray)
json["payload"]["discard_pile"] = nlohmann::json::array();
json["payload"]["players"] = nlohmann::json::array();
for (int i = 0; i < 10000; ++i) {
json["payload"]["discard_pile"].push_back({{"card_color", "Red"}, {"card_type", "5"}});
json["payload"]["discard_pile"].push_back({{"card_color", "red"}, {"card_type", "5"}});
}
json["payload"]["hand_card"] = nlohmann::json::array();
json["payload"]["current_player"] = 0;