BlackJackTest::testTie() - Code Metrics - Inspection of "Kmom 10" - EmilHacklin/MCV-v2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 101f2d...06b8a6 )

by Emil

created 2025-08-29 16:48 UTC

BlackJackTest::testTie() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	40
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	1
eloc	21
nc	1
nop	0
dl	0
loc	40
rs	9.584
c	1
b	1
f	0

<?php

namespace App\Tests\Game;

use App\Cards\Card;
use App\Cards\DeckOfCards;
use App\Game\BlackJack;
use App\Game\BlackJack\Dealer;
use App\Game\BlackJack\Player;
use PHPUnit\Framework\TestCase;
use App\Cards\CardGraphic;

/**
 * Test cases for class BlackJack.
 */
class BlackJackTest extends TestCase
{
    /**
     * testCreateObject
     *
     * Construct object and verify that the object has the expected
     * properties, use no arguments.
     *
     * @return void
     */
    public function testCreateObject(): void
    {
        $blackJack = new BlackJack();
        $this->assertInstanceOf(BlackJack::class, $blackJack);

        $blackJack->newGame();

        $res = $blackJack->stateOfGame();
        $this->assertEquals("1", $res["numOfPlayers"]);
    }

    /**
     * testToFewPlayers
     *
     * @return void
     */
    public function testToFewPlayers(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage("Can't have less then one player in Black Jack");
        new BlackJack(0); // Less than 1
    }

    /**
     * testToManyPlayers
     *
     * @return void
     */
    public function testToManyPlayers(): void
    {
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Maximum of ' . BlackJack::MAX_PLAYERS . ' players in Black Jack');
        new BlackJack(BlackJack::MAX_PLAYERS + 1);
    }

    /**
     * testBooleans
     *
     * Test the boolean values
     *
     * @return void
     */
    public function testBooleans(): void
    {
        $blackJack = new BlackJack();

        $blackJack->newGame();

        $playerBust = $blackJack->isPlayerBust();
        $this->assertEquals(false, $playerBust);

        $dealerBust = $blackJack->isDealerBust();
        $this->assertEquals(false, $dealerBust);
    }

    /**
     * testSettersAndGetters
     *
     * Test the setters and getters
     *
     * @return void
     */
    public function testSettersAndGetters(): void
    {
        $blackJack = new BlackJack();

        $deck = new DeckOfCards();
        $deck->drawCard();

        //Test setDeck
        $blackJack->setDeck($deck);

        //Test get
        $deckCopy = $blackJack->getDeck();
        $this->assertEquals(51, count($deckCopy->getString()));

        //Test setPlayers
        $player = new Player();
        $player->setGameState(Player::STAYED);
        $player->addCard(new Card("A", "Spade"));
        $player->addCard(new Card("King", "Spade"));

        $blackJack->setPlayers([$player, $player]);

        //Test getPlayers
        $players = $blackJack->getPlayers();
        $numOfPlayers = $blackJack->getNumOfPlayers();
        $this->assertEquals(2, count($players));
        $this->assertEquals(2, $numOfPlayers);

        //Test setPlayer
        $players[1]->addCard(new Card("A", "Spade"));
        $blackJack->setPlayer(1, $players[1]);

        $players = $blackJack->getPlayers();
        $numOfPlayers = $blackJack->getNumOfPlayers();
        $this->assertEquals(2, count($players));
        $this->assertEquals(2, $numOfPlayers);

        //Test setPlayer out of bounds
        $blackJack->setPlayer(2, $player);

        $players = $blackJack->getPlayers();
        $this->assertEquals(3, count($players[1]->getString()));

        //Test setDealer
        $dealer = new Dealer();
        $dealer->addCard(new Card("10", "Heart"));
        $dealer->addCard(new Card("10", "Heart"));

        $blackJack->setDealer($dealer);

        //Test getDealer
        $dealerCopy = $blackJack->getDealer();
        $this->assertEquals(2, count($dealerCopy->getString()));

        //Check if to many players
        $players = [];
        for ($i = 0; $i <= BlackJack::MAX_PLAYERS; $i++) {
            $players[] = $player;
        }

        $blackJack->setPlayers([$player]);

        $players = $blackJack->getPlayers();
        $numOfPlayers = $blackJack->getNumOfPlayers();
        $this->assertEquals(1, count($players));
        $this->assertEquals(1, $numOfPlayers);
    }

    /**
     * testStayPlayer
     *
     * Test the stay action of the player
     *
     * @return void
     */
    public function testStayPlayer(): void
    {
        $blackJack = new BlackJack();

        $blackJack->newGame();

        $blackJack->stayPlayer();

        $res = $blackJack->stateOfGame();

        $this->assertNotEquals("Undecided", $res["gameStates"][0]);

        $blackJack->stayPlayer(-1);
    }

    /**
     * testHitPlayer
     *
     * Test the hit action of the player
     *
     * @return void
     */
    public function testHitPlayer(): void
    {
        $blackJack = new BlackJack();

        $blackJack->newGame();

        $blackJack->hitPlayer();

        $player = $blackJack->getPlayers()[0];

        $this->assertEquals(3, count($player->getString()));

        //Check if gone bust
        while ($blackJack->isPlayerBust() === false) {
            $blackJack->hitPlayer();
        }

        $player = $blackJack->getPlayers()[0];
        $this->assertEquals(0, $player->getBet());

        //Check if index out of bound
        $blackJack->hitPlayer(-1);
    }

    /**
     * testDoubleDownPlayer
     *
     * Test the double down action of the player
     *
     * @return void
     */
    public function testDoubleDownPlayer(): void
    {
        $blackJack = new BlackJack();

        $blackJack->newGame();

        $blackJack->doubleDownPlayer();

        $player = $blackJack->getPlayers()[0];

        $this->assertEquals(3, count($player->getString()));

        (true === $player->isBust()) ?
            $this->assertEquals(Player::DEFAULT_STARTING_CREDITS - (BlackJack::MINIMUM_BET * 2), $player->getCredits()) :
            $this->assertGreaterThanOrEqual(Player::DEFAULT_STARTING_CREDITS - (BlackJack::MINIMUM_BET * 2), $player->getCredits());

        $blackJack->newGame();

        $blackJack->doubleDownPlayer(-1);
    }
}


1			<?php
2
3			namespace App\Tests\Game;
4
5			use App\Cards\Card;
6			use App\Cards\DeckOfCards;
7			use App\Game\BlackJack;
8			use App\Game\BlackJack\Dealer;
9			use App\Game\BlackJack\Player;
10			use PHPUnit\Framework\TestCase;
11			use App\Cards\CardGraphic;
12
13			/**
14			* Test cases for class BlackJack.
15			*/
16			class BlackJackTest extends TestCase
17			{
18			/**
19			* testCreateObject
20			*
21			* Construct object and verify that the object has the expected
22			* properties, use no arguments.
23			*
24			* @return void
25			*/
26			public function testCreateObject(): void
27			{
28			$blackJack = new BlackJack();
29			$this->assertInstanceOf(BlackJack::class, $blackJack);
30
31			$blackJack->newGame();
32
33			$res = $blackJack->stateOfGame();
34			$this->assertEquals("1", $res["numOfPlayers"]);
35			}
36
37			/**
38			* testToFewPlayers
39			*
40			* @return void
41			*/
42			public function testToFewPlayers(): void
43			{
44			$this->expectException(\RuntimeException::class);
45			$this->expectExceptionMessage("Can't have less then one player in Black Jack");
46			new BlackJack(0); // Less than 1
47			}
48
49			/**
50			* testToManyPlayers
51			*
52			* @return void
53			*/
54			public function testToManyPlayers(): void
55			{
56			$this->expectException(\RuntimeException::class);
57			$this->expectExceptionMessage('Maximum of ' . BlackJack::MAX_PLAYERS . ' players in Black Jack');
58			new BlackJack(BlackJack::MAX_PLAYERS + 1);
59			}
60
61			/**
62			* testBooleans
63			*
64			* Test the boolean values
65			*
66			* @return void
67			*/
68			public function testBooleans(): void
69			{
70			$blackJack = new BlackJack();
71
72			$blackJack->newGame();
73
74			$playerBust = $blackJack->isPlayerBust();
75			$this->assertEquals(false, $playerBust);
76
77			$dealerBust = $blackJack->isDealerBust();
78			$this->assertEquals(false, $dealerBust);
79			}
80
81			/**
82			* testSettersAndGetters
83			*
84			* Test the setters and getters
85			*
86			* @return void
87			*/
88			public function testSettersAndGetters(): void
89			{
90			$blackJack = new BlackJack();
91
92			$deck = new DeckOfCards();
93			$deck->drawCard();
94
95			//Test setDeck
96			$blackJack->setDeck($deck);
97
98			//Test get
99			$deckCopy = $blackJack->getDeck();
100			$this->assertEquals(51, count($deckCopy->getString()));
101
102			//Test setPlayers
103			$player = new Player();
104			$player->setGameState(Player::STAYED);
105			$player->addCard(new Card("A", "Spade"));
106			$player->addCard(new Card("King", "Spade"));
107
108			$blackJack->setPlayers([$player, $player]);
109
110			//Test getPlayers
111			$players = $blackJack->getPlayers();
112			$numOfPlayers = $blackJack->getNumOfPlayers();
113			$this->assertEquals(2, count($players));
114			$this->assertEquals(2, $numOfPlayers);
115
116			//Test setPlayer
117			$players[1]->addCard(new Card("A", "Spade"));
118			$blackJack->setPlayer(1, $players[1]);
119
120			$players = $blackJack->getPlayers();
121			$numOfPlayers = $blackJack->getNumOfPlayers();
122			$this->assertEquals(2, count($players));
123			$this->assertEquals(2, $numOfPlayers);
124
125			//Test setPlayer out of bounds
126			$blackJack->setPlayer(2, $player);
127
128			$players = $blackJack->getPlayers();
129			$this->assertEquals(3, count($players[1]->getString()));
130
131			//Test setDealer
132			$dealer = new Dealer();
133			$dealer->addCard(new Card("10", "Heart"));
134			$dealer->addCard(new Card("10", "Heart"));
135
136			$blackJack->setDealer($dealer);
137
138			//Test getDealer
139			$dealerCopy = $blackJack->getDealer();
140			$this->assertEquals(2, count($dealerCopy->getString()));
141
142			//Check if to many players
143			$players = [];
144			for ($i = 0; $i <= BlackJack::MAX_PLAYERS; $i++) {
145			$players[] = $player;
146			}
147
148			$blackJack->setPlayers([$player]);
149
150			$players = $blackJack->getPlayers();
151			$numOfPlayers = $blackJack->getNumOfPlayers();
152			$this->assertEquals(1, count($players));
153			$this->assertEquals(1, $numOfPlayers);
154			}
155
156			/**
157			* testStayPlayer
158			*
159			* Test the stay action of the player
160			*
161			* @return void
162			*/
163			public function testStayPlayer(): void
164			{
165			$blackJack = new BlackJack();
166
167			$blackJack->newGame();
168
169			$blackJack->stayPlayer();
170
171			$res = $blackJack->stateOfGame();
172
173			$this->assertNotEquals("Undecided", $res["gameStates"][0]);
174
175			$blackJack->stayPlayer(-1);
176			}
177
178			/**
179			* testHitPlayer
180			*
181			* Test the hit action of the player
182			*
183			* @return void
184			*/
185			public function testHitPlayer(): void
186			{
187			$blackJack = new BlackJack();
188
189			$blackJack->newGame();
190
191			$blackJack->hitPlayer();
192
193			$player = $blackJack->getPlayers()[0];
194
195			$this->assertEquals(3, count($player->getString()));
196
197			//Check if gone bust
198			while ($blackJack->isPlayerBust() === false) {
199			$blackJack->hitPlayer();
200			}
201
202			$player = $blackJack->getPlayers()[0];
203			$this->assertEquals(0, $player->getBet());
204
205			//Check if index out of bound
206			$blackJack->hitPlayer(-1);
207			}
208
209			/**
210			* testDoubleDownPlayer
211			*
212			* Test the double down action of the player
213			*
214			* @return void
215			*/
216			public function testDoubleDownPlayer(): void
217			{
218			$blackJack = new BlackJack();
219
220			$blackJack->newGame();
221
222			$blackJack->doubleDownPlayer();
223
224			$player = $blackJack->getPlayers()[0];
225
226			$this->assertEquals(3, count($player->getString()));
227
228			(true === $player->isBust()) ?
229			$this->assertEquals(Player::DEFAULT_STARTING_CREDITS - (BlackJack::MINIMUM_BET * 2), $player->getCredits()) :
230			$this->assertGreaterThanOrEqual(Player::DEFAULT_STARTING_CREDITS - (BlackJack::MINIMUM_BET * 2), $player->getCredits());
231
232			$blackJack->newGame();
233
234			$blackJack->doubleDownPlayer(-1);
235			}
236			}
237

EmilHacklin / MCV-v2

Push — main ( 101f2d...06b8a6 )

BlackJackTest::testTie() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like