From f93b71405b08dd76d8c2aed121a6d17fea6bc1b5 Mon Sep 17 00:00:00 2001
From: fdai7892 <homan.halimi@informatik.hs-fulda.de>
Date: Wed, 7 Feb 2024 22:00:29 +0100
Subject: [PATCH] =?UTF-8?q?=20Funktion=20ge=C3=A4ndert=20und=20define=20hi?=
 =?UTF-8?q?nzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 build/test/cache/defines_dependency.yml       |   4 +-
 .../test_duellist_spielesammlung_projekt.c    | 509 ++++++++++++++++++
 .../test_duellist_spielesammlung_projekt.d    |   5 +-
 .../c/test_duellist_spielesammlung_projekt.o  | Bin 564 -> 10168 bytes
 ...t_duellist_spielesammlung_projekt_runner.o | Bin 4523 -> 7114 bytes
 .../test_duellist_spielesammlung_projekt.c    | 509 ++++++++++++++++++
 .../test_duellist_spielesammlung_projekt.c    |   4 +-
 .../test_duellist_spielesammlung_projekt.pass |  14 -
 ...t_duellist_spielesammlung_projekt_runner.c |  66 ++-
 src/main/duellist-spielesammlung-projekt.c    |  12 +-
 src/main/duellist-spielesammlung-projekt.h    |   3 +
 11 files changed, 1100 insertions(+), 26 deletions(-)
 delete mode 100644 build/test/results/test_duellist_spielesammlung_projekt.pass

diff --git a/build/test/cache/defines_dependency.yml b/build/test/cache/defines_dependency.yml
index 2fbf0ff..9ce76ed 100644
--- a/build/test/cache/defines_dependency.yml
+++ b/build/test/cache/defines_dependency.yml
@@ -1 +1,3 @@
---- {}
+---
+src/main/duellist-spielesammlung-projekt.c:
+- TEST
diff --git a/build/test/cache/test_duellist_spielesammlung_projekt.c b/build/test/cache/test_duellist_spielesammlung_projekt.c
index e69de29..74c99eb 100644
--- a/build/test/cache/test_duellist_spielesammlung_projekt.c
+++ b/build/test/cache/test_duellist_spielesammlung_projekt.c
@@ -0,0 +1,509 @@
+#include "src/main/duellist-spielesammlung-projekt.h"
+#include "C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h"
+
+
+
+
+
+
+void setUp(void) {}
+
+
+
+void tearDown(void) {}
+
+
+
+
+
+void test_coinflip_player_x_starts(void) {
+
+
+
+    TicTacToeGame game;
+
+
+
+
+
+    GameResult result = initializeGame(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(19), UNITY_DISPLAY_STYLE_INT);
+
+    do {if ((game.currentPlayer == PLAYER_X || game.currentPlayer == PLAYER_O)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(20)));}} while(0);
+
+}
+
+
+
+void test_coinflip_player_o_starts(void) {
+
+
+
+    TicTacToeGame game;
+
+
+
+
+
+    GameResult result = initializeGame(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(31), UNITY_DISPLAY_STYLE_INT);
+
+    do {if ((game.currentPlayer == PLAYER_X || game.currentPlayer == PLAYER_O)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(32)));}} while(0);
+
+}
+
+
+
+void test_vertical_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {PLAYER_X, EMPTY, EMPTY},
+
+                                     {PLAYER_X, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(46), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_horizontal_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, PLAYER_X, PLAYER_X},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(60), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+void test_diagonal_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_X, EMPTY},
+
+                                     {EMPTY, EMPTY, PLAYER_X}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(73), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_valid_move_and_switch_player(void) {
+
+
+
+    TicTacToeGame game = { .board = {{EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_X };
+
+
+
+
+
+    GameResult moveResult = makeMove(&game, 1, 1);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((moveResult)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(87), UNITY_DISPLAY_STYLE_INT);
+
+    UnityAssertEqualNumber((UNITY_INT)((PLAYER_O)), (UNITY_INT)((game.currentPlayer)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(88), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+
+
+void test_invalid_input(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, 0, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(103), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_valid_input(void) {
+
+
+
+    TicTacToeGame game = { .board = {{EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_X };
+
+
+
+
+
+    GameResult result = makeMove(&game, 1, 1);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(117), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+
+
+void test_invalid_input_type1(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, -1, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(132), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_invalid_input_type2(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, 0, 3);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(146), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_getNumberOfMoves_returns_correct_number_of_moves(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int moves = getNumberOfMoves(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((moves)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(160), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_BoardFull_returns_false_when_board_is_not_full(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int boardFull = BoardFull(&game);
+
+
+
+
+
+    do {if (!(boardFull)) {} else {UnityFail( ((" Expected FALSE Was TRUE")), (UNITY_UINT)((UNITY_UINT)(174)));}} while(0);
+
+}
+
+void test_BoardFull_returns_true_when_board_is_full(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, PLAYER_X, PLAYER_O},
+
+                                     {PLAYER_O, PLAYER_O, PLAYER_X},
+
+                                     {PLAYER_X, PLAYER_X, PLAYER_O}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int boardFull = BoardFull(&game);
+
+
+
+
+
+    do {if ((boardFull)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(187)));}} while(0);
+
+}
+
+void test_getCurrentPlayer_returns_correct_player(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_O };
+
+
+
+
+
+    Player currentPlayer = getCurrentPlayer(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((PLAYER_O)), (UNITY_INT)((currentPlayer)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(200), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+void test_FieldEmpty_returns_true_for_empty_field(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}} };
+
+
+
+
+
+    int result = FieldEmpty(&game, 0, 2);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((1)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(212), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_FieldEmpty_returns_false_for_nonempty_field(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}} };
+
+
+
+
+
+    int result = FieldEmpty(&game, 0, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(225), UNITY_DISPLAY_STYLE_INT);
+
+}
diff --git a/build/test/dependencies/test_duellist_spielesammlung_projekt.d b/build/test/dependencies/test_duellist_spielesammlung_projekt.d
index 598e388..96c50a9 100644
--- a/build/test/dependencies/test_duellist_spielesammlung_projekt.d
+++ b/build/test/dependencies/test_duellist_spielesammlung_projekt.d
@@ -1,2 +1,5 @@
 build/test/out/c/test_duellist_spielesammlung_projekt.o: \
- src/test/test_duellist_spielesammlung_projekt.c
+ src/test/test_duellist_spielesammlung_projekt.c \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \
+ C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h \
+ src/main/duellist-spielesammlung-projekt.h
diff --git a/build/test/out/c/test_duellist_spielesammlung_projekt.o b/build/test/out/c/test_duellist_spielesammlung_projekt.o
index 61d37cc0e772ffe0431c67854c52481ec4c738ff..7bf0ec4c005b05cfab59d5b317568befb9176236 100644
GIT binary patch
literal 10168
zcmcIq3v3+48J@k{voEooII$BajZu$cAXV@=PC^JF4?FhRxHwMa2O(<8az5{!m)yhM
z+jAbIf;LnnMYM#{@@QHiD6~L9l=2i%C<Hk``k+lAX(BLfqS7j;Q3DcHtES&Svpak1
zyK_PXEAQ?<-~a#LKlAU*?9QCKl?q13t`K8OxTGp!OW$g7SzIm(GIl^=Y<|5cUx-_X
zExaZ?6t$vxcE!XNw(zC!U^ZJ!myg{*cBYq*>htlGd@IJl*U}^^Di!BcGIr5a#vVOK
zK%{PA)oYrXmr5HF+R=ut*&ayPEnesWLnz%+$JkS!7qAaE&bQ=Z0od0!!1oC3UbpQ~
z6m}P1;<0N$Y3p1MB<z+h^MGWxx4;hVz2s7l-7qTj66_Azac4qHc^TM!{MN6$BCk77
zTy;z2z;3nSee&KN`S9k*hhyyx)wL+$URfjVc(~BEH>hJORe*8pn<FQ8eymva{O+@A
zVXtz(JeylzqgZE(LUn}qSw{(xeX%HG5$c0%Eb=>CaXTn(hXi<3l*YyFm;iZG#v&&K
zcoJ!2lV&6gg9&vdA5J4%>()aAIVf(2M34#f5a1`R$BIu@4-v%4hg}a*t8q~}CT>nW
zgzn7w=z`ni`Pi`YME@-V2c9ARXE6lX?zc}pJQg|0BjBmqca`pwrhWqqCWHbaJ0n!G
z-(FQ{>OQ5N`}#FL2GB3vCq-0lj}fJ_eNs-Xa97E5(q<$mkhix})AM@Jr<So?VJIMW
zsLwVHr*TZ0h8qj(HX#k4>f`Z?aA$rzw|xrrqP{j38OIg32?I-jy!U(aliz>uAy2!H
zU`n>9UbhR|)9U4C=)V6~J$8QWLndbPN2wNS1HEqYdgsm)d13kBjT{t#4vE`QJFL(-
z^Q<VH5V|7Gr?5Hx5_wL9#nl`3OoP=9OMa!YPA1;0Pk7<&Cui^AB%i$Iml&M(i$}B_
z1iUgur-S_GOcSyb&VA1AIFMuXETe*s_=@!M{HX60jY__vog(V3p~%(|J!a`cq5j^1
zNN7Ve8|rB7?u#&2!OL7jCLoxL?<^jjsY++hK&Y*`IkYsqIJ_{_n6h$dePu#V>!uMy
zF>1z!R~i>DTN-Liu*$3%YqIpL#V^`WPERI{tfgf~3_Yo5qp4IfmriISX69ObvlWi9
zw&j}!vbvewG@MCA)0@_%^>))3)i<^4+09mFWRt_t=w)cM8K|*rL6F~=@7mOeHkgYu
z-?{sM_{VXfC!^A3It!@fS!26yZ5z=c2aL4E%G3{_3Mgf<;i$>Vc_F9{WpaZ_*i@>?
zOga&AifVZ-oi!3^B$9jszVhsF#<W6SG#KDc{KCzYGTVvA2q-~mF92Ua&~W2mx$7<M
zNaGvm>FVF84RrPNFJ8p_J8ICmY|MtPA4gO2%$WbKJsu<Gzx#dw0acABGf^}^6;&nr
zpk`z!b0PKjThQgFXd{-1y!{oFD8yi){*n0ADcWE(t26a2QU#}I@nkf?)VE1jiIRc5
zsfVak4L2l}NY%px)WS6v#}i=cpQt=%ie{xo;^}A#E=P#2p7}bux+6?IO7n`JD)Mcd
zQ&|Poj;a6HiBhFXP50lS%tZgJ5?N{Q>RaF4x>4)v-`E||kPlW{O0$g3D5b&@VrD5F
za$cO09tdkF>PD(%?A($%#QQ=?B?1;_y*zT&GS*tu4=Ql3DWwBtdr@86<*mJJPf^uC
z&lNrEHuSLD*ff#qzW#N+t(_6ApAGxpQWgg=u=+9FJLtjt4{?A^Z_Amcp0-HQLyy;g
zm@8CA(XLxjBiYRSM>rnz;^^K-IbP}DMAU7h^`2a6P&b+X9pxGHf$Hg^ye>}qEc3t1
z;aX841jv~>&~c8=;b>PPo#Ehn9IVd|&;bv9i247_RiS*9aD(nIT-PwYbr1u;!{lxI
zoAM<3?tIK8AK_j-kT$Gs%>M!JpMHXRk))}tyc0K}?X%2vo0<Q4A891CK8mHY{{=5d
zm16#1dO=Yg=6}%(M@+MW4{ZOh3KZ>PO7p*5pjo<v`ClnO`)Fnxj;7J(eOx(%54%7h
zT82^AH_+A=>Fa~k)pKQQcUQZ%cHNZ`rc`ydu8n9Lx_X#Ti0!?t8<=0nT|L_R-gTY5
z<ft-VCz98zXLCtRL=`i@YDcL05k-isUEjYEcN*4_UhOJy+u}OrW4`st=r(kOz>F-6
zXU-4Q{ucKsgPEu~!~(OZz-Y<K0<(#&f%)ln94CJj_{5d@`i)qBG}fQdsWL23_cK`3
zTIft#2VPf0k<^H_O*3^XXQs1SJethvT0CQF=}cPZsyJCO<?ScS85>17W$#8vv!;=F
zn8Nw?w9lf7DDRBp>f4hnO>dbw!S11ceYK>1LQ)^_P`~M=PUx0B{6vyu{bLyn%9y2%
zh}<bJJdFzOqRQ=^ju)t?^@|QQaHhOUX>)76hVt8yOC}{Juk@B-J+1NFYX;H;JyRZQ
zf#()Zo|NQ|JLI1u#WUl$PDU;g?qyGBEIYz|uVL_r2)~gL?)OA^*c$<vaVCtlnNd9}
zTj69T&8HVF6W3CtXUg|l5ksVC2{xxhiteyu%(jhw=#65eN25t&NHfwSIZLCDjYUkk
z=|Q}#?nHZ)z1K;i-A-kB5BUy_EH@p6G|f!eHbc_9ENQOu(0tuXlUEm}TzfB8PZ?ed
z1q*o5oTSIy^tyX$!IVu?K_Hs3MiN}@AsF%!i1?H#4U>tM-C|g=Vc7+{NAN<wn^)*A
z$=74^@%-8|gwpS&9WtVcOgfs>wis!qta=}B1M!#+OPUr>wK}~1nB9!+nY86FG+!eb
z=3$dmWM;94;ZiTdsBT(D%<(_(5E>zB@MY<LzQ=!o*FTmq(($A*V&_83Xjv<2;w`4s
znc#}^r2Is3&Gm5APtLVfa#i3n-sU<bxvD%|)ecvkrAN*7%oZdxh_1-!RQA?ob!%XR
zDO9o{rp!>z57t!pgY$wjl$mAKb?CUWnLoI^;<Ab^bY{Pzbk!&j)N@%^O%nnK8dyce
zDtLfnIz+N6zW_>nL)Iw%U_}M_lFO7TNwf@(Q_n@%3cR9h^3`)!U>RGfD#QVw0QpqS
zhrS-x(<B$ir`ueCt{UR1wrNllG&3X(4?VL6tWG^@;5$t;h<t0q%IdkI5*N;;Mz_rQ
z{+hWId=^-3L*E?6X1jHzVqKU`^t)pXEyU|_qVwaxkhTwJ9Ye)2bVwij7bHdb_p~Zp
z6(9_!;w-UPY<W}4NGG;58R=LuH>6`R)zq6C+_rdO<JP51nv%v~lZj$eLQiFzuyzYC
z6k<%*hmvq?To_*59BytJ)zd>6vnfYkE=^!(6d@JG&|>^$=&Zp?ui{WG^b;(<!o$=m
z&V(7z(oGD~EI`Z~S!>A12)#pCVo?Vpo|FJjP~D1ED^_nl>|0R7e5z9R4P1TSC=0G!
zRSX;Ub<82tRgSRI5mt=`w+G*V3V&M&<OPZ5L9SBza)F1BBeLL}Pz3GD(clrzI_e0%
zay+=0_!_pqSrYWAfp1Xy@Zm2_dZDt;wzlP=`D=}I=Z0{`OoUKw<m>Im<}ZqcH~Jv;
z3mnS!UZ(5_D)TB;br&*EU5QT086T#t(}Lght*HvEc@-8yw*op$jV1M)psU6i$H^Rj
z-ykO-?j1Pk3#XKRFLXz7(j4ge-zfc`2RwwjmeP~&i4yt{bpOF=*)I#p-+q(dw`Z)C
zg49DFg8wx81to2KxAQs>M+@{1*l$3oCyuzwL3NykoY6~8+SnWv<3{KonMD6%=p*(=
zgX{0+VITCrwm)24eOBh_81(IUi1cAoOs^sb&p}@-k0H1;K;LG6GD?4HV@kA<Y%Yh*
zvy<4+^t1qHE$hVfA}-N$pNF%IZN{~cW7p#<>>hz6><&N@c5gxwb_>uZ`njc+ZG<H3
zej%~<Bz76<CF~4H!tMb`P289ECIxm{N+~=|q5T0Qp*<wAGCU`NS&)R?y%MX$QxMp4
zNW$)RNc8()EqhsF^~iQJ$Cf}6ZMzhbXxn$C_F<`gOlqeh%Zs@0GDsrE4oHhR_K?K>
zDX|dVkirfmjDAq7U=QLt3uhVoIj-k%>=mfb=TaEHLc0=@z^;(eZmGRfVh>2^nADz<
zn1UJzmR3lDdA-E0mePGv`?$njl2SQ+p7J`+h9vmbOH7kkN=kP~?E?~fLP~E*?Qw~n
zl2RRg_3>yIKoZfGNGTz;qY`^mVlPPS4Jn<J+S3xN!dHM`UI<A<TP?A*QraQ4H%sg;
zDeafqw<UI5N~fiEW~CE@`T_meUBTyP5w{FuMo1xONUCKmQo2S;H%RFoDZM16aVgPf
zg<xrrQoEFfr9^KVVfRxh?U&N~QledRVK-k&-BJqkT|xxM@!!*oCE&-{M!LvD6Q7;D
ztgsOCaT}?Y!VQopL)?a=-@+Bi%R?SSiN2{_oBb%!7rTobLFpRAaFLThs6{T~M~N0J
zE^+}7S`xX)av-$Ia*=Kzv}|*cI1pM7y2uScS_ApW(?Do}>)O!Uu?0<ak$TjH*6=R!
zB_On6;38Xr(C&ml!g>Gg0XlrB(<kSJklZ8xKRw_K8&~H@`TymC#um59`wtH^7B(~!
z79I~#5FBVMZ0P?xmhf`^<tf{Sp0r<~o>_S8vu)5=*o1Jk0Z7jA2OC18VMG7ZQAqW!
zZG*`LHVuxe=l*xw29pD9&hzM;!bi3ZhBR!3QJU$f<elDR;y@4Q!gNX}KOE%30%TDE
z(pG@1EkLva<k|vchX>h(Qg}!o%q8$CAI~^)ba2qrM`g*3rW4pJu??}T&>cC8pAf|V
z`7~_bzMX~jVJ*(LOwV#rp~(d)B<#seTr$gLZgI6-Q46(a!7iW)y8r_8Y%SQXd_$+i
zCWbKaZj|J^@qHjx#ES0?HJ8*ZvNfN0*Ghyc+^d^(JFS#csSQ41f3|y#!n(+wYSB&4
zlGY`6U_X;yicW7>1|I!(u|2Huo&DA<eyy}3U(H36_OB5F=Nt9-#Y>NE&fD46Qqj%&
YTI_x?ZQ^rentViD>Djbpc^lB|e@qLHp#T5?

delta 216
zcmdntzlBB8hmnl|1T+{K7`VVJRz|&&)QXacj`9;NLYVYTfDDj?1A~B*zM&bArw8R2
znS<5C2o)fM1!xK~a9}WSm^?>PMOiN`Gba@)^Y1?cLpoTY8nW8Sj7q|+V1db!N}&@2
qSd@LC(jXTyGb$r12D2j=7$(Q4C{NDgQs>qyN=Yn9RH>?}VgLZ-rW^tQ

diff --git a/build/test/out/c/test_duellist_spielesammlung_projekt_runner.o b/build/test/out/c/test_duellist_spielesammlung_projekt_runner.o
index 70dfa7409334a2d094cec374838ce3fa0aa581a3..02e689ff7a87c4614fdf0dc7b36ad26362d99ada 100644
GIT binary patch
literal 7114
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

literal 4523
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

diff --git a/build/test/preprocess/files/test_duellist_spielesammlung_projekt.c b/build/test/preprocess/files/test_duellist_spielesammlung_projekt.c
index e69de29..74c99eb 100644
--- a/build/test/preprocess/files/test_duellist_spielesammlung_projekt.c
+++ b/build/test/preprocess/files/test_duellist_spielesammlung_projekt.c
@@ -0,0 +1,509 @@
+#include "src/main/duellist-spielesammlung-projekt.h"
+#include "C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h"
+
+
+
+
+
+
+void setUp(void) {}
+
+
+
+void tearDown(void) {}
+
+
+
+
+
+void test_coinflip_player_x_starts(void) {
+
+
+
+    TicTacToeGame game;
+
+
+
+
+
+    GameResult result = initializeGame(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(19), UNITY_DISPLAY_STYLE_INT);
+
+    do {if ((game.currentPlayer == PLAYER_X || game.currentPlayer == PLAYER_O)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(20)));}} while(0);
+
+}
+
+
+
+void test_coinflip_player_o_starts(void) {
+
+
+
+    TicTacToeGame game;
+
+
+
+
+
+    GameResult result = initializeGame(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(31), UNITY_DISPLAY_STYLE_INT);
+
+    do {if ((game.currentPlayer == PLAYER_X || game.currentPlayer == PLAYER_O)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(32)));}} while(0);
+
+}
+
+
+
+void test_vertical_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {PLAYER_X, EMPTY, EMPTY},
+
+                                     {PLAYER_X, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(46), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_horizontal_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, PLAYER_X, PLAYER_X},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(60), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+void test_diagonal_win(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_X, EMPTY},
+
+                                     {EMPTY, EMPTY, PLAYER_X}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = checkGameResult(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((GAME_WIN)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(73), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_valid_move_and_switch_player(void) {
+
+
+
+    TicTacToeGame game = { .board = {{EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_X };
+
+
+
+
+
+    GameResult moveResult = makeMove(&game, 1, 1);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((moveResult)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(87), UNITY_DISPLAY_STYLE_INT);
+
+    UnityAssertEqualNumber((UNITY_INT)((PLAYER_O)), (UNITY_INT)((game.currentPlayer)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(88), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+
+
+void test_invalid_input(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, 0, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(103), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_valid_input(void) {
+
+
+
+    TicTacToeGame game = { .board = {{EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_X };
+
+
+
+
+
+    GameResult result = makeMove(&game, 1, 1);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((SUCCESS)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(117), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+
+
+void test_invalid_input_type1(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, -1, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(132), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_invalid_input_type2(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                          .currentPlayer = PLAYER_O };
+
+
+
+
+
+    GameResult result = makeMove(&game, 0, 3);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((INVALID_MOVE)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(146), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_getNumberOfMoves_returns_correct_number_of_moves(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int moves = getNumberOfMoves(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((moves)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(160), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_BoardFull_returns_false_when_board_is_not_full(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int boardFull = BoardFull(&game);
+
+
+
+
+
+    do {if (!(boardFull)) {} else {UnityFail( ((" Expected FALSE Was TRUE")), (UNITY_UINT)((UNITY_UINT)(174)));}} while(0);
+
+}
+
+void test_BoardFull_returns_true_when_board_is_full(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, PLAYER_X, PLAYER_O},
+
+                                     {PLAYER_O, PLAYER_O, PLAYER_X},
+
+                                     {PLAYER_X, PLAYER_X, PLAYER_O}},
+
+                           .currentPlayer = PLAYER_X };
+
+
+
+
+
+    int boardFull = BoardFull(&game);
+
+
+
+
+
+    do {if ((boardFull)) {} else {UnityFail( ((" Expected TRUE Was FALSE")), (UNITY_UINT)((UNITY_UINT)(187)));}} while(0);
+
+}
+
+void test_getCurrentPlayer_returns_correct_player(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}},
+
+                           .currentPlayer = PLAYER_O };
+
+
+
+
+
+    Player currentPlayer = getCurrentPlayer(&game);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((PLAYER_O)), (UNITY_INT)((currentPlayer)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(200), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+void test_FieldEmpty_returns_true_for_empty_field(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}} };
+
+
+
+
+
+    int result = FieldEmpty(&game, 0, 2);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((1)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(212), UNITY_DISPLAY_STYLE_INT);
+
+}
+
+
+
+void test_FieldEmpty_returns_false_for_nonempty_field(void) {
+
+
+
+    TicTacToeGame game = { .board = {{PLAYER_X, EMPTY, EMPTY},
+
+                                     {EMPTY, PLAYER_O, EMPTY},
+
+                                     {EMPTY, EMPTY, EMPTY}} };
+
+
+
+
+
+    int result = FieldEmpty(&game, 0, 0);
+
+
+
+
+
+    UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((result)), (
+
+   ((void *)0)
+
+   ), (UNITY_UINT)(225), UNITY_DISPLAY_STYLE_INT);
+
+}
diff --git a/build/test/preprocess/includes/test_duellist_spielesammlung_projekt.c b/build/test/preprocess/includes/test_duellist_spielesammlung_projekt.c
index dcd024e..c5516ae 100644
--- a/build/test/preprocess/includes/test_duellist_spielesammlung_projekt.c
+++ b/build/test/preprocess/includes/test_duellist_spielesammlung_projekt.c
@@ -1 +1,3 @@
---- []
+---
+- C:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h
+- src/main/duellist-spielesammlung-projekt.h
diff --git a/build/test/results/test_duellist_spielesammlung_projekt.pass b/build/test/results/test_duellist_spielesammlung_projekt.pass
deleted file mode 100644
index 5046e33..0000000
--- a/build/test/results/test_duellist_spielesammlung_projekt.pass
+++ /dev/null
@@ -1,14 +0,0 @@
----
-:source:
-  :path: src/test
-  :file: test_duellist_spielesammlung_projekt.c
-:successes: []
-:failures: []
-:ignores: []
-:counts:
-  :total: 0
-  :passed: 0
-  :failed: 0
-  :ignored: 0
-:stdout: []
-:time: 0.014711899915710092
diff --git a/build/test/runners/test_duellist_spielesammlung_projekt_runner.c b/build/test/runners/test_duellist_spielesammlung_projekt_runner.c
index bba31ca..f4e3d01 100644
--- a/build/test/runners/test_duellist_spielesammlung_projekt_runner.c
+++ b/build/test/runners/test_duellist_spielesammlung_projekt_runner.c
@@ -10,6 +10,22 @@ char* GlobalOrderError;
 /*=======External Functions This Runner Calls=====*/
 extern void setUp(void);
 extern void tearDown(void);
+extern void test_coinflip_player_x_starts(void);
+extern void test_coinflip_player_o_starts(void);
+extern void test_vertical_win(void);
+extern void test_horizontal_win(void);
+extern void test_diagonal_win(void);
+extern void test_valid_move_and_switch_player(void);
+extern void test_invalid_input(void);
+extern void test_valid_input(void);
+extern void test_invalid_input_type1(void);
+extern void test_invalid_input_type2(void);
+extern void test_getNumberOfMoves_returns_correct_number_of_moves(void);
+extern void test_BoardFull_returns_false_when_board_is_not_full(void);
+extern void test_BoardFull_returns_true_when_board_is_full(void);
+extern void test_getCurrentPlayer_returns_correct_player(void);
+extern void test_FieldEmpty_returns_true_for_empty_field(void);
+extern void test_FieldEmpty_returns_false_for_nonempty_field(void);
 
 
 /*=======Mock Management=====*/
@@ -26,12 +42,6 @@ static void CMock_Destroy(void)
 {
 }
 
-/*=======Setup (stub)=====*/
-void setUp(void) {}
-
-/*=======Teardown (stub)=====*/
-void tearDown(void) {}
-
 /*=======Test Reset Options=====*/
 void resetTest(void);
 void resetTest(void)
@@ -48,10 +58,54 @@ void verifyTest(void)
   CMock_Verify();
 }
 
+/*=======Test Runner Used To Run Each Test=====*/
+static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)
+{
+    Unity.CurrentTestName = name;
+    Unity.CurrentTestLineNumber = line_num;
+#ifdef UNITY_USE_COMMAND_LINE_ARGS
+    if (!UnityTestMatches())
+        return;
+#endif
+    Unity.NumberOfTests++;
+    UNITY_CLR_DETAILS();
+    UNITY_EXEC_TIME_START();
+    CMock_Init();
+    if (TEST_PROTECT())
+    {
+        setUp();
+        func();
+    }
+    if (TEST_PROTECT())
+    {
+        tearDown();
+        CMock_Verify();
+    }
+    CMock_Destroy();
+    UNITY_EXEC_TIME_STOP();
+    UnityConcludeTest();
+}
+
 /*=======MAIN=====*/
 int main(void)
 {
   UnityBegin("test_duellist_spielesammlung_projekt.c");
+  run_test(test_coinflip_player_x_starts, "test_coinflip_player_x_starts", 11);
+  run_test(test_coinflip_player_o_starts, "test_coinflip_player_o_starts", 23);
+  run_test(test_vertical_win, "test_vertical_win", 35);
+  run_test(test_horizontal_win, "test_horizontal_win", 49);
+  run_test(test_diagonal_win, "test_diagonal_win", 62);
+  run_test(test_valid_move_and_switch_player, "test_valid_move_and_switch_player", 76);
+  run_test(test_invalid_input, "test_invalid_input", 92);
+  run_test(test_valid_input, "test_valid_input", 106);
+  run_test(test_invalid_input_type1, "test_invalid_input_type1", 121);
+  run_test(test_invalid_input_type2, "test_invalid_input_type2", 135);
+  run_test(test_getNumberOfMoves_returns_correct_number_of_moves, "test_getNumberOfMoves_returns_correct_number_of_moves", 149);
+  run_test(test_BoardFull_returns_false_when_board_is_not_full, "test_BoardFull_returns_false_when_board_is_not_full", 163);
+  run_test(test_BoardFull_returns_true_when_board_is_full, "test_BoardFull_returns_true_when_board_is_full", 176);
+  run_test(test_getCurrentPlayer_returns_correct_player, "test_getCurrentPlayer_returns_correct_player", 189);
+  run_test(test_FieldEmpty_returns_true_for_empty_field, "test_FieldEmpty_returns_true_for_empty_field", 202);
+  run_test(test_FieldEmpty_returns_false_for_nonempty_field, "test_FieldEmpty_returns_false_for_nonempty_field", 215);
 
   return UnityEnd();
 }
diff --git a/src/main/duellist-spielesammlung-projekt.c b/src/main/duellist-spielesammlung-projekt.c
index 4267153..63b1395 100644
--- a/src/main/duellist-spielesammlung-projekt.c
+++ b/src/main/duellist-spielesammlung-projekt.c
@@ -106,16 +106,22 @@ int FieldEmpty(const TicTacToeGame* game, int row, int col) {
 }
 
 GameResult checkGameResult(const TicTacToeGame* game) {
-    // Prüfen, ob ein Sieg oder ein Unentschieden vorliegt und das entsprechende Ergebnis zurückgeben
+    // Überprüfen, ob ein Sieg oder ein Unentschieden vorliegt und das entsprechende Ergebnis zurückgeben
     for (int i = 0; i < 3; ++i) {
-        //Zeilen und Spalten auf einen Gewinn prüfen
+        // Zeilen und Spalten auf einen Gewinn prüfen
         if ((game->board[i][0] == game->board[i][1] && game->board[i][1] == game->board[i][2] && game->board[i][0] != EMPTY) ||
             (game->board[0][i] == game->board[1][i] && game->board[1][i] == game->board[2][i] && game->board[0][i] != EMPTY)) {
             return GAME_WIN;
         }
     }
 
-   
+    // Diagonalen auf einen Gewinn prüfen
+    if ((game->board[0][0] == game->board[1][1] && game->board[1][1] == game->board[2][2] && game->board[0][0] != EMPTY) ||
+        (game->board[0][2] == game->board[1][1] && game->board[1][1] == game->board[2][0] && game->board[0][2] != EMPTY)) {
+        return GAME_WIN;
+    }
+
+    // Überprüfen auf Unentschieden
     int draw = 1;
     for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j) {
diff --git a/src/main/duellist-spielesammlung-projekt.h b/src/main/duellist-spielesammlung-projekt.h
index 63f6ef9..514eff2 100644
--- a/src/main/duellist-spielesammlung-projekt.h
+++ b/src/main/duellist-spielesammlung-projekt.h
@@ -1,6 +1,9 @@
 #ifndef DUELLIST_SPIELESAMMLUNG_PROJEKT_H
 #define DUELLIST_SPIELESAMMLUNG_PROJEKT_H
 
+#define MIN_AGE 12
+
+
 
 typedef enum {
     SUCCESS,