Continous Integration in der Praxis Gruppenarbeit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

325 lines
8.6 KiB

  1. using MiniGames.Shared.Models;
  2. using Xunit;
  3. namespace MiniGamesTests
  4. {
  5. public class TicTacToeBrettTest
  6. {
  7. const int LEER = TicTacToeBrett.LEER;
  8. public TicTacToeBrett TestBrett(
  9. int f00 = LEER, int f10 = LEER, int f20 = LEER,
  10. int f01 = LEER, int f11 = LEER, int f21 = LEER,
  11. int f02 = LEER, int f12 = LEER, int f22 = LEER
  12. )
  13. {
  14. return new(
  15. new int[,]
  16. {
  17. { f00, f01, f02, },
  18. { f10, f11, f12, },
  19. { f20, f21, f22, },
  20. }
  21. );
  22. }
  23. [Theory]
  24. [InlineData(4, 0,
  25. LEER, LEER, LEER,
  26. LEER, 0
  27. )]
  28. [InlineData(0, 1,
  29. 1
  30. )]
  31. [InlineData(8, 2,
  32. LEER, LEER, LEER,
  33. LEER, LEER, LEER,
  34. LEER, LEER, 2
  35. )]
  36. [InlineData(6, 3,
  37. LEER, LEER, LEER,
  38. LEER, LEER, LEER,
  39. 3, LEER, LEER
  40. )]
  41. [InlineData(3, 4,
  42. LEER, LEER, LEER,
  43. 4, LEER, LEER,
  44. LEER, LEER, LEER
  45. )]
  46. public void Set_FreiesFeldBelegenTest(int pos, int wert,
  47. int a = LEER, int b = LEER, int c = LEER,
  48. int d = LEER, int e = LEER, int f = LEER,
  49. int g = LEER, int h = LEER, int i = LEER
  50. )
  51. {
  52. // arrange
  53. TicTacToeBrett brett = new();
  54. TicTacToeBrett erwartetesBrett = TestBrett(a, b, c, d, e, f, g, h, i);
  55. bool erwartetGesetzt = true;
  56. // act
  57. bool erhaltenGesetzt = brett.Set(pos, wert);
  58. // assert
  59. Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
  60. Assert.True(brett.Gleich(erwartetesBrett));
  61. }
  62. [Fact]
  63. public void Set_BelegtesFeldBelegenTest()
  64. {
  65. // arrange
  66. TicTacToeBrett brett = TestBrett(1);
  67. TicTacToeBrett erwartetesBrett = TestBrett(1);
  68. int pos = 0;
  69. int wert = 1;
  70. bool erwartetGesetzt = false;
  71. // act
  72. bool erhaltenGesetzt = brett.Set(pos, wert);
  73. // assert
  74. Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
  75. Assert.True(brett.Gleich(erwartetesBrett));
  76. }
  77. [Theory]
  78. [InlineData(-1)]
  79. [InlineData(9)]
  80. public void Set_OutOfBoundsTest(int pos)
  81. {
  82. // arrange
  83. TicTacToeBrett brett = new();
  84. TicTacToeBrett erwartetesBrett = new();
  85. int wert = 0;
  86. bool erwartetGesetzt = false;
  87. // act
  88. bool erhaltenGesetzt = brett.Set(pos, wert);
  89. // assert
  90. Assert.Equal(erwartetGesetzt, erhaltenGesetzt);
  91. Assert.True(brett.Gleich(erwartetesBrett));
  92. }
  93. [Fact]
  94. public void Gleich_LeereBretterGleichTest()
  95. {
  96. // arrange
  97. TicTacToeBrett b1 = new();
  98. TicTacToeBrett b2 = new();
  99. bool erwartetGleich = true;
  100. // act
  101. bool erhaltenGleich = b1.Gleich(b2);
  102. // assert
  103. Assert.Equal(erwartetGleich, erhaltenGleich);
  104. }
  105. [Fact]
  106. public void Gleich_NichtLeereBretterGleichTest()
  107. {
  108. // arrange
  109. TicTacToeBrett b1 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
  110. TicTacToeBrett b2 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
  111. bool erwartetGleich = true;
  112. // act
  113. bool erhaltenGleich = b1.Gleich(b2);
  114. // assert
  115. Assert.Equal(erwartetGleich, erhaltenGleich);
  116. }
  117. [Fact]
  118. public void Gleich_ErsteUngleichTest()
  119. {
  120. // arrange
  121. TicTacToeBrett b1 = TestBrett(1);
  122. TicTacToeBrett b2 = TestBrett(2);
  123. bool erwartetGleich = false;
  124. // act
  125. bool erhaltenGleich = b1.Gleich(b2);
  126. // assert
  127. Assert.Equal(erwartetGleich, erhaltenGleich);
  128. }
  129. [Fact]
  130. public void Gleich_LetzteUngleichTest()
  131. {
  132. // arrange
  133. TicTacToeBrett b1 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
  134. TicTacToeBrett b2 = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 10);
  135. bool erwartetGleich = false;
  136. // act
  137. bool erhaltenGleich = b1.Gleich(b2);
  138. // assert
  139. Assert.Equal(erwartetGleich, erhaltenGleich);
  140. }
  141. [Fact]
  142. public void Voll_LeeresBrettTest()
  143. {
  144. // arrange
  145. TicTacToeBrett brett = TestBrett();
  146. bool erwartetVoll = false;
  147. // act
  148. bool erhaltenVoll = brett.Voll();
  149. // assert
  150. Assert.Equal(erwartetVoll, erhaltenVoll);
  151. }
  152. [Fact]
  153. public void Voll_VollesBrettTest()
  154. {
  155. // arrange
  156. TicTacToeBrett brett = TestBrett(1, 2, 3, 4, 5, 6, 7, 8, 9);
  157. bool erwartetVoll = true;
  158. // act
  159. bool erhaltenVoll = brett.Voll();
  160. // assert
  161. Assert.Equal(erwartetVoll, erhaltenVoll);
  162. }
  163. [Fact]
  164. public void Voll_FastVollesBrettTest()
  165. {
  166. // arrange
  167. TicTacToeBrett brett = TestBrett(1, 2, 3, 4, 5, 6, 7, 8);
  168. bool erwartetVoll = false;
  169. // act
  170. bool erhaltenVoll = brett.Voll();
  171. // assert
  172. Assert.Equal(erwartetVoll, erhaltenVoll);
  173. }
  174. [Fact]
  175. public void Gewinner_LeeresFeldTest()
  176. {
  177. // arrange
  178. TicTacToeBrett brett = TestBrett();
  179. int erwarteterGewinner = LEER;
  180. // act
  181. int erhaltenerGewinner = brett.Gewinner();
  182. // assert
  183. Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
  184. }
  185. [Theory]
  186. // Vertikale Reihe 1
  187. [InlineData(0,
  188. 0, LEER, LEER,
  189. 0, LEER, LEER,
  190. 0, LEER, LEER
  191. )]
  192. // Vertikale Reihe 2
  193. [InlineData(1,
  194. LEER, 1, LEER,
  195. LEER, 1, LEER,
  196. LEER, 1, LEER
  197. )]
  198. // Vertikale Reihe 3
  199. [InlineData(2,
  200. LEER, LEER, 2,
  201. LEER, LEER, 2,
  202. LEER, LEER, 2
  203. )]
  204. // Horizontale Reihe 1
  205. [InlineData(3,
  206. 3, 3, 3,
  207. LEER, LEER, LEER,
  208. LEER, LEER, LEER
  209. )]
  210. // Horizontale Reihe 2
  211. [InlineData(4,
  212. LEER, LEER, LEER,
  213. 4, 4, 4,
  214. LEER, LEER, LEER
  215. )]
  216. // Horizontale Reihe 3
  217. [InlineData(5,
  218. LEER, LEER, LEER,
  219. LEER, LEER, LEER,
  220. 5, 5, 5
  221. )]
  222. // Diagonale Reihe links oben nach rechts unten
  223. [InlineData(6,
  224. 6, LEER, LEER,
  225. LEER, 6, LEER,
  226. LEER, LEER, 6
  227. )]
  228. // Diagonale Reihe rechts oben nach links unten
  229. [InlineData(7,
  230. LEER, LEER, 7,
  231. LEER, 7, LEER,
  232. 7, LEER, LEER
  233. )]
  234. public void Gewinner_VolleReihenTest(int gewinner,
  235. int a = LEER, int b = LEER, int c = LEER,
  236. int d = LEER, int e = LEER, int f = LEER,
  237. int g = LEER, int h = LEER, int i = LEER
  238. )
  239. {
  240. // arrange
  241. TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
  242. int erwarteterGewinner = gewinner;
  243. // act
  244. int erhaltenerGewinner = brett.Gewinner();
  245. // assert
  246. Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
  247. }
  248. [Theory]
  249. [InlineData(
  250. 0, LEER, 0,
  251. LEER, LEER, LEER,
  252. 0, LEER, 0
  253. )]
  254. [InlineData(
  255. 1, 1, LEER,
  256. 1, 1, LEER,
  257. LEER, LEER, LEER
  258. )]
  259. [InlineData(
  260. 2, 2, LEER,
  261. LEER, LEER, 2,
  262. LEER, 2, 2
  263. )]
  264. [InlineData(
  265. 1, 1, 2,
  266. 1, 3, 3,
  267. 2, 2, 3
  268. )]
  269. public void Gewinner_NichtVolleReihenTest(
  270. int a = LEER, int b = LEER, int c = LEER,
  271. int d = LEER, int e = LEER, int f = LEER,
  272. int g = LEER, int h = LEER, int i = LEER
  273. )
  274. {
  275. // arrange
  276. TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
  277. int erwarteterGewinner = LEER;
  278. // act
  279. int erhaltenerGewinner = brett.Gewinner();
  280. // assert
  281. Assert.Equal(erwarteterGewinner, erhaltenerGewinner);
  282. }
  283. }
  284. }