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 * @date 2025.11.15
*/ */
#include "gtest/gtest.h"
#include "../../../src/game/Card.h" #include "../../../src/game/Card.h"
#include "gtest/gtest.h"
TEST(card_test, card_test_1) 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.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::NUM0); 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.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) 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.getColor(), UNO::GAME::CardColor::BLUE);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::REVERSE); EXPECT_EQ(card.getType(), UNO::GAME::CardType::REVERSE);
EXPECT_EQ(card.colorToString(), std::string("Blue")); EXPECT_EQ(card.colorToString(), std::string("blue"));
EXPECT_EQ(card.typeToString(), std::string("Reverse")); EXPECT_EQ(card.typeToString(), std::string("reverse"));
EXPECT_EQ(card.toString(), std::string("Blue Reverse")); EXPECT_EQ(card.toString(), std::string("blue_reverse"));
} }
TEST(card_test, card_test_3) 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.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILD); EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILD);
EXPECT_EQ(card.colorToString(), std::string("Red")); EXPECT_EQ(card.colorToString(), std::string("red"));
EXPECT_EQ(card.typeToString(), std::string("Wild")); EXPECT_EQ(card.typeToString(), std::string("wild_wild"));
EXPECT_EQ(card.toString(), std::string("Wild")); EXPECT_EQ(card.toString(), std::string("wild_wild"));
} }
TEST(card_test, card_test_4) 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.getColor(), UNO::GAME::CardColor::RED);
EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILDDRAWFOUR); EXPECT_EQ(card.getType(), UNO::GAME::CardType::WILDDRAWFOUR);
EXPECT_EQ(card.colorToString(), std::string("Red")); EXPECT_EQ(card.colorToString(), std::string("red"));
EXPECT_EQ(card.typeToString(), std::string("Wild Draw 4")); EXPECT_EQ(card.typeToString(), std::string("wild_draw_four"));
EXPECT_EQ(card.toString(), std::string("Wild Draw 4")); 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[2].getName(), "qkp");
ASSERT_EQ(players[3].getName(), "lzh"); ASSERT_EQ(players[3].getName(), "lzh");
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
clientGameState.updateStateByDraw(); 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)); clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::REVERSE));
ASSERT_EQ(clientGameState.getIsReversed(), true); ASSERT_EQ(clientGameState.getIsReversed(), true);
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "lzh"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 3);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "kpq"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 1);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "pkq"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 0);
clientGameState.updateStateByDraw(); 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)); 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)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 2);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::DRAW2)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 4);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 8);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 12);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 16);
clientGameState.updateStateByCard(UNO::GAME::Card(UNO::GAME::CardColor::BLUE, UNO::GAME::CardType::WILDDRAWFOUR)); 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); ASSERT_EQ(clientGameState.getDrawCount(), 20);
clientGameState.updateStateByDraw(); clientGameState.updateStateByDraw();
ASSERT_EQ(clientGameState.getPlayers()[3].getName(), "lzh"); ASSERT_EQ(clientGameState.getPlayers()[3].getName(), "lzh");
ASSERT_EQ(clientGameState.getPlayers()[3].getRemainingCardCount(), 120); ASSERT_EQ(clientGameState.getPlayers()[3].getRemainingCardCount(), 120);
ASSERT_EQ(clientGameState.getCurrentPlayer()->getName(), "qkp"); ASSERT_EQ(clientGameState.getCurrentPlayerId(), 2);
ASSERT_EQ(clientGameState.getDrawCount(), 0); ASSERT_EQ(clientGameState.getDrawCount(), 0);
} }
@@ -108,11 +108,11 @@ TEST(game_state_test, game_state_test_2)
} }
while (true) { while (true) {
for (auto it = serverGameState.getCurrentPlayer()->getCards().begin();; it++) { for (auto it = serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getCards().begin();; it++) {
const auto player = serverGameState.getCurrentPlayer(); const auto &player = serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()];
auto prevCards = player->getCards(); auto prevCards = player.getCards();
if (it == serverGameState.getCurrentPlayer()->getCards().end()) { if (it == serverGameState.getPlayers()[serverGameState.getCurrentPlayerId()].getCards().end()) {
size_t prevCount = player->getRemainingCardCount(); size_t prevCount = player.getRemainingCardCount();
size_t drawCount = serverGameState.getDrawCount(); size_t drawCount = serverGameState.getDrawCount();
if (drawCount == 0) { if (drawCount == 0) {
drawCount = 1; drawCount = 1;
@@ -120,11 +120,11 @@ TEST(game_state_test, game_state_test_2)
serverGameState.updateStateByDraw(); serverGameState.updateStateByDraw();
size_t afterCount = player->getRemainingCardCount(); size_t afterCount = player.getRemainingCardCount();
ASSERT_EQ(prevCount + drawCount, afterCount); ASSERT_EQ(prevCount + drawCount, afterCount);
for (auto card : prevCards) { for (auto card : prevCards) {
ASSERT_LE(prevCards.count(card), player->getCards().count(card)); ASSERT_LE(prevCards.count(card), player.getCards().count(card));
} }
break; break;
@@ -132,17 +132,17 @@ TEST(game_state_test, game_state_test_2)
if (it->canBePlayedOn(serverGameState.getDiscardPile().getFront(), serverGameState.getDrawCount())) { if (it->canBePlayedOn(serverGameState.getDiscardPile().getFront(), serverGameState.getDrawCount())) {
auto card = *it; auto card = *it;
size_t prevCount = player->getCards().count(card); size_t prevCount = player.getCards().count(card);
serverGameState.updateStateByCard(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(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()) { 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; break;
} }
} }

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

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