diff --git a/CMakeLists.txt b/CMakeLists.txt
index 19de2b55eeedd216bc2415ab693b7e49eb877a45..060e39e7cd3313512519ffad474a5040b51966c3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -117,8 +117,8 @@ else()
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
- target_link_libraries(Blackjack-client ${CMAKE_SOURCE_DIR}/sockpp/cmake-build-debug/libsockpp.so Threads::Threads)
- target_link_libraries(Blackjack-server ${CMAKE_SOURCE_DIR}/sockpp/cmake-build-debug/libsockpp.so Threads::Threads)
+ target_link_libraries(Blackjack-client ${CMAKE_SOURCE_DIR}/sockpp/cmake-build-debug/libsockpp.dylib Threads::Threads)
+ target_link_libraries(Blackjack-server ${CMAKE_SOURCE_DIR}/sockpp/cmake-build-debug/libsockpp.dylib Threads::Threads)
endif()
# copy assets (images) to binary directory
@@ -130,3 +130,6 @@ set(CMAKE_CXX_FLAGS "--coverage")
add_library(Blackjack-lib ${SERVER_SOURCE_FILES})
# set compile directives for server-library
target_compile_definitions(Blackjack-lib PRIVATE BLACKJACK_SERVER=1 RAPIDJSON_HAS_STDSTRING=1)
+
+add_subdirectory(googletest)
+add_subdirectory(unit-tests)
\ No newline at end of file
diff --git a/source/general/game_state/card.cpp b/source/general/game_state/card.cpp
index 68c2ec90f1edb93c662ca8fe26868d1dfd37c51c..0015d98f163d8511cd872a70d2f748794be4bf1a 100644
--- a/source/general/game_state/card.cpp
+++ b/source/general/game_state/card.cpp
@@ -1,11 +1,13 @@
#include "card.hpp"
+#include <utility>
+
#include "../exceptions/BlackjackException.hpp"
-card::card(std::string id) : unique_serializable(id) { }
+card::card(std::string id) : unique_serializable(std::move(id)) { }
card::card(std::string id, serializable_value<int> *val, serializable_value<int>* suit)
- : unique_serializable(id), _value(val), _suit(suit)
+ : unique_serializable(std::move(id)), _value(val), _suit(suit)
{ }
card::card(int val, int suit) :
diff --git a/source/general/game_state/game_state.cpp b/source/general/game_state/game_state.cpp
index abd2e521bab2024fa26499f6cdec0e3dba18584b..91d26ff6d764926f43f59d6a7207b20f8b7dc7c8 100644
--- a/source/general/game_state/game_state.cpp
+++ b/source/general/game_state/game_state.cpp
@@ -4,6 +4,8 @@
#include "game_state.hpp"
+#include <utility>
+
#include "../exceptions/BlackjackException.hpp"
#include "../serialization/vector_utils.h"
@@ -19,7 +21,7 @@ game_state::game_state() : unique_serializable() {
this->_starting_player_idx = new serializable_value<int>(0);
}
-game_state::game_state(std::string id) : unique_serializable(id) {
+game_state::game_state(std::string id) : unique_serializable(std::move(id)) {
this->_players = std::vector<player*>();
this->_shoe = new shoe();
this->_dealers_hand = new hand();
@@ -34,7 +36,7 @@ game_state::game_state(std::string id, std::vector<player*>& players, shoe* shoe
hand* dealers_hand, serializable_value<bool>* is_started,
serializable_value<bool>* is_finished, serializable_value<int>* round_number,
serializable_value<int>* current_player_idx, serializable_value<int>* starting_player_idx)
- : unique_serializable(id),
+ : unique_serializable(std::move(id)),
_players(players),
_shoe(shoe),
_dealers_hand(dealers_hand),
@@ -109,7 +111,7 @@ shoe* game_state::get_shoe() const {
}
player* game_state::get_current_player() const {
- if(_current_player_idx == nullptr || _players.size() == 0) {
+ if(_current_player_idx == nullptr || _players.empty()) {
return nullptr;
}
return _players[_current_player_idx->get_value()];
diff --git a/source/general/game_state/hand.hpp b/source/general/game_state/hand.hpp
index 7c1cc530bad80ef7e8b39968bb16e59b330429d4..793f3ecf96fca1012c594ac864dc1258a05b787f 100644
--- a/source/general/game_state/hand.hpp
+++ b/source/general/game_state/hand.hpp
@@ -23,15 +23,15 @@ public:
virtual void write_into_json(rapidjson::Value& json, rapidjson::Document::AllocatorType& allocator) const override;
// accessors
- int get_nof_cards() const;
- const std::vector<card*> get_cards() const;
+ int get_nof_cards() const; //checked
+ const std::vector<card*> get_cards() const; //checked
// state update functions
- void setup_round(std::string& err);
- bool add_card(card* card, std::string& err);
+ void setup_round(std::string& err); //TODO
+ bool add_card(card* card, std::string& err); //checked
- int get_points(std::string &err);
- bool is_over_21(std::string &err);
+ int get_points(std::string &err); //checked
+ bool is_over_21(std::string &err); //TODO
std::vector<card*>::iterator get_card_iterator();
};
diff --git a/unit-tests/CMakeLists.txt b/unit-tests/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dee96892d5549094e85220f229626b299e933bff
--- /dev/null
+++ b/unit-tests/CMakeLists.txt
@@ -0,0 +1,13 @@
+project(Blackjack-unit-tests)
+
+set(TEST_SOURCE_FILES
+ hand.cpp
+ card.cpp
+ player.cpp
+ shoe.cpp)
+
+add_executable(Blackjack-tests ${TEST_SOURCE_FILES})
+
+target_compile_definitions(Blackjack-tests PRIVATE BLACKJACK_SERVER=1 RAPIDJSON_HAS_STDSTRING=1)
+
+target_link_libraries(Blackjack-tests gtest gtest_main Blackjack-lib)
\ No newline at end of file
diff --git a/unit-tests/card.cpp b/unit-tests/card.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dfad54aa7c2d5eaa9f3a527cb54617d12c8bcd0
--- /dev/null
+++ b/unit-tests/card.cpp
@@ -0,0 +1,4 @@
+//
+// Created by Flavia Taras on 24.05.22.
+//
+
diff --git a/unit-tests/hand.cpp b/unit-tests/hand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..14a4caa0b92ac4edfb0957dc67472ba807faa647
--- /dev/null
+++ b/unit-tests/hand.cpp
@@ -0,0 +1,234 @@
+//
+// Created by Flavia Taras on 20.05.22.
+//
+
+//TODO: check the get_points function in many different ways with different amounts of aces and stuff
+//TODO try to get extra cards when you already have over 21 points
+//TODO: adding the same card more than the number of decks in a shoe should not work
+
+#include "gtest/gtest.h"
+#include "../source/general/game_state/hand.hpp"
+
+
+/* A test fixture allows to reuse the same configuration of objects for all
+ * tests in a test suite. The name of the fixture must match the test suite.
+ *
+ * For each test defined with TEST_F(), googletest will create a fresh test
+ * fixture at runtime, immediately initialize it via SetUp(), run the test,
+ * clean up by calling TearDown(), and then delete the test fixture.
+ * Note that different tests in the same test suite have different test fixture
+ * objects, and googletest always deletes a test fixture before it creates the
+ * next one. googletest does not reuse the same test fixture for multiple
+ * tests. Any changes one test makes to the fixture do not affect other tests.
+ */
+class HandTest : public ::testing::Test {
+
+protected:
+ virtual void SetUp() {
+ cards.resize(8); //TODO: do we need this... rather just declare a shoe...
+ for (int i = 1; i < 14; ++i) {
+ for (int j = 0; j < 5; ++j) {
+ cards[i].push_back(new card(i, j));
+ }
+ }
+ }
+
+ /* Any object and subroutine declared here can be accessed in the tests */
+
+ // cards[i][j] holds a pointer to the j-th copy of a card of value i
+ std::vector<std::vector<card*>> cards;
+ hand player_hand;
+ std::string err;
+};
+
+// Adding one card to an empty hand must succeed
+TEST_F(HandTest, AddOneCard) {
+ EXPECT_TRUE(player_hand.add_card(cards[1][0], err));
+ std::vector<card*> expected_hand = {cards[1][0]};
+ EXPECT_EQ(expected_hand, player_hand.get_cards());
+}
+
+// The initial state must be an empty hand
+TEST_F(HandTest, AddNoCards) {
+ std::vector<card*> expected_hand = {};
+ EXPECT_EQ(expected_hand, player_hand.get_cards());
+}
+
+// Adding several cards with different values to an empty hand must succeed
+TEST_F(HandTest, AddManyCards) {
+ EXPECT_TRUE(player_hand.add_card(cards[1][0], err));
+ EXPECT_TRUE(player_hand.add_card(cards[3][0], err));
+ EXPECT_TRUE(player_hand.add_card(cards[13][0], err));
+ std::vector<card*> expected_hand = {cards[1][0], cards[3][0], cards[13][0]};
+ EXPECT_EQ(expected_hand, player_hand.get_cards());
+}
+
+// Adding several cards with duplicate values to an empty hand must succeed
+TEST_F(HandTest, AddManyCardsWithDuplicates) {
+ EXPECT_TRUE(player_hand.add_card(cards[1][0], err));
+ EXPECT_TRUE(player_hand.add_card(cards[1][1], err));
+ EXPECT_TRUE(player_hand.add_card(cards[1][2], err));
+ EXPECT_TRUE(player_hand.add_card(cards[3][0], err));
+ EXPECT_TRUE(player_hand.add_card(cards[3][1], err));
+ EXPECT_TRUE(player_hand.add_card(cards[13][0], err));
+ std::vector<card*> expected_hand = {cards[1][0], cards[1][1], cards[1][2],
+ cards[3][0], cards[3][1], cards[13][0]};
+ EXPECT_EQ(expected_hand, player_hand.get_cards());
+}
+
+// The score of a hand with a single ace must be 11
+TEST_F(HandTest, ScoreOneAce) {
+ player_hand.add_card(cards[1][0], err);
+ EXPECT_EQ(11, player_hand.get_points(err));
+}
+
+// The score of a hand with a single card must be equal to the card's value
+TEST_F(HandTest, ScoreOneCard) {
+ player_hand.add_card(cards[8][0], err);
+ EXPECT_EQ(8, player_hand.get_points(err));
+}
+
+//The score of a hand with a single face card must be 10
+TEST_F(HandTest, ScoreOneFaceCard) {
+ player_hand.add_card(cards[12][0], err);
+ EXPECT_EQ(10, player_hand.get_points(err));
+}
+
+//TODO: do we even test for this?
+// The score of an empty hand must be zero
+TEST_F(HandTest, ScoreNoCards) {
+ EXPECT_EQ(0, player_hand.get_points(err));
+}
+
+//The score of a hand with 2 aces must be 12
+TEST_F(HandTest, ScoreTwoAces) {
+ player_hand.add_card(cards[1][0], err);
+ EXPECT_EQ(11, player_hand.get_points(err));
+ player_hand.add_card(cards[1][1], err);
+ EXPECT_EQ(12, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value
+TEST_F(HandTest, ScoreManyCards) {
+ player_hand.add_card(cards[2][0], err);
+ ASSERT_EQ(2, player_hand.get_points(err));
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(5, player_hand.get_points(err));
+ player_hand.add_card(cards[9][0], err);
+ EXPECT_EQ(14, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value
+//also if one of the cards is a face card
+TEST_F(HandTest, ScoreManyCardsWithFaceCard) {
+ player_hand.add_card(cards[1][0], err);
+ ASSERT_EQ(11, player_hand.get_points(err));
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(14, player_hand.get_points(err));
+ player_hand.add_card(cards[13][0], err);
+ EXPECT_EQ(14, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value
+//also in the special case of having an ace (drawn first)
+TEST_F(HandTest, ScoreManyCardsWithAceFirst) {
+ player_hand.add_card(cards[1][0], err);
+ ASSERT_EQ(11, player_hand.get_points(err));
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(14, player_hand.get_points(err));
+ player_hand.add_card(cards[7][0], err);
+ EXPECT_EQ(21, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value
+//also in the special case of having an ace (drawn last)
+TEST_F(HandTest, ScoreManyCardsWithAceLast) {
+ player_hand.add_card(cards[7][0], err);
+ ASSERT_EQ(7, player_hand.get_points(err));
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(10, player_hand.get_points(err));
+ player_hand.add_card(cards[1][0], err);
+ EXPECT_EQ(21, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value even
+// if several cards have the same value
+TEST_F(HandTest, ScoreManyCardsWithDuplicates) {
+ player_hand.add_card(cards[2][0], err);
+ ASSERT_EQ(2, player_hand.get_points(err));
+ player_hand.add_card(cards[2][1], err);
+ ASSERT_EQ(4, player_hand.get_points(err));
+ player_hand.add_card(cards[2][2], err);
+ ASSERT_EQ(6, player_hand.get_points(err));
+ player_hand.add_card(cards[7][0], err);
+ ASSERT_EQ(13, player_hand.get_points(err));
+ player_hand.add_card(cards[7][1], err);
+ ASSERT_EQ(20, player_hand.get_points(err));
+ player_hand.add_card(cards[9][0], err);
+ EXPECT_EQ(29, player_hand.get_points(err));
+}
+
+// Each addition of a card must increase the score by that card's value even
+// if several cards have the same value (with aces)
+TEST_F(HandTest, ScoreManyCardsWithDuplicatesAces) {
+ player_hand.add_card(cards[2][0], err);
+ ASSERT_EQ(2, player_hand.get_points(err));
+ player_hand.add_card(cards[2][1], err);
+ ASSERT_EQ(4, player_hand.get_points(err));
+ player_hand.add_card(cards[2][2], err);
+ ASSERT_EQ(6, player_hand.get_points(err));
+ player_hand.add_card(cards[1][0], err);
+ ASSERT_EQ(17, player_hand.get_points(err));
+ player_hand.add_card(cards[1][1], err);
+ ASSERT_EQ(18, player_hand.get_points(err));
+ player_hand.add_card(cards[9][0], err);
+ EXPECT_EQ(17, player_hand.get_points(err));
+}
+
+// A hand of one card must have count 1
+TEST_F(HandTest, CountOneCard) {
+ player_hand.add_card(cards[1][0], err);
+ EXPECT_EQ(1, player_hand.get_nof_cards());
+}
+
+// An empty hand must have count 0
+TEST_F(HandTest, CountNoCards) {
+ EXPECT_EQ(0, player_hand.get_nof_cards());
+}
+
+// Each addition of a card must increase the count by 1
+TEST_F(HandTest, CountManyCards) {
+ player_hand.add_card(cards[1][0], err);
+ ASSERT_EQ(1, player_hand.get_nof_cards());
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(2, player_hand.get_nof_cards());
+ player_hand.add_card(cards[7][0], err);
+ EXPECT_EQ(3, player_hand.get_nof_cards());
+}
+
+// Each addition of a card must increase the count by 1 even if several cards
+// have the same value
+TEST_F(HandTest, CountManyCardsWithDuplicates) {
+ player_hand.add_card(cards[1][0], err);
+ ASSERT_EQ(1, player_hand.get_nof_cards());
+ player_hand.add_card(cards[1][1], err);
+ ASSERT_EQ(2, player_hand.get_nof_cards());
+ player_hand.add_card(cards[1][2], err);
+ ASSERT_EQ(3, player_hand.get_nof_cards());
+ player_hand.add_card(cards[3][0], err);
+ ASSERT_EQ(4, player_hand.get_nof_cards());
+ player_hand.add_card(cards[3][1], err);
+ ASSERT_EQ(5, player_hand.get_nof_cards());
+ player_hand.add_card(cards[7][0], err);
+ EXPECT_EQ(6, player_hand.get_nof_cards());
+}
+
+// The setup function has to remove all cards in a hand
+TEST_F(HandTest, SetupRound) {
+ player_hand.add_card(cards[1][0], err);
+ player_hand.add_card(cards[7][0], err);
+ player_hand.add_card(cards[9][0], err);
+ player_hand.setup_round(err);
+ std::vector<card*> expected_hand = {};
+ EXPECT_EQ(expected_hand, player_hand);
+}
\ No newline at end of file
diff --git a/unit-tests/player.cpp b/unit-tests/player.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dfad54aa7c2d5eaa9f3a527cb54617d12c8bcd0
--- /dev/null
+++ b/unit-tests/player.cpp
@@ -0,0 +1,4 @@
+//
+// Created by Flavia Taras on 24.05.22.
+//
+
diff --git a/unit-tests/shoe.cpp b/unit-tests/shoe.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dfad54aa7c2d5eaa9f3a527cb54617d12c8bcd0
--- /dev/null
+++ b/unit-tests/shoe.cpp
@@ -0,0 +1,4 @@
+//
+// Created by Flavia Taras on 24.05.22.
+//
+