louis.dufour
/
LouisDuf-DouShouQi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add(Master): Test unitaire

Browse Source
master
Louis DUFOUR 1 year ago
parent 7289c64546
commit e922f48980
3 changed files with 115 additions and 122 deletions
Show Stats Download Patch File Download Diff File

8
Model/Tests/ModelTests/ModelTests.swift
Unescape View File

@ -43,20 +43,20 @@ class BoardTests: XCTestCase {
// Testez removePiece(atRow:andColumn:)
func testRemovePiece() {
let initialCell = testBoard.getCell(atRow: 0, column: 0)
let initialCell = testBoard.getCell(atRow: 0, atColumn: 0)
XCTAssertNotNil(initialCell?.piece)
let result = testBoard.removePiece(atRow: 0, andColumn: 0)
XCTAssertEqual(result, .ok)
// Vérifiez que la pièce a été supprimée correctement
let removedCell = testBoard.getCell(atRow: 0, column: 0)
let removedCell = testBoard.getCell(atRow: 0, atColumn: 0)
XCTAssertNil(removedCell?.piece)
}
// Testez insert(piece:atRow:andColumn:)
func testInsertPiece() {
// Supprimez toute pièce existante dans la case cible (si elle existe)
let initialCell = testBoard.getCell(atRow: 0, column: 0)
let initialCell = testBoard.getCell(atRow: 0, atColumn: 0)
if initialCell?.piece != nil {
let removeResult = testBoard.removePiece(atRow: 0, andColumn: 0)
XCTAssertEqual(removeResult, .ok)
@ -67,7 +67,7 @@ class BoardTests: XCTestCase {
XCTAssertEqual(insertResult, .ok)
// Vérifiez que la pièce a été insérée correctement
let cell = testBoard.getCell(atRow: 0, column: 0)
let cell = testBoard.getCell(atRow: 0, atColumn: 0)
XCTAssertNotNil(cell?.piece)
XCTAssertEqual(cell?.piece?.owner, .player1)
XCTAssertEqual(cell?.piece?.animal, .lion)

94
Model/Tests/ModelTests/PlayerTests.swift
Unescape View File

@ -5,88 +5,44 @@
// Created by Louis DUFOUR on 31/01/2024.
//
import Foundation
import Model
import XCTest
@testable import Model // Remplacez 'YourModuleName' par le nom réel de votre module
/*
// Mocks et Stubs
class MockBoard: Board {
// Implémentez les méthodes nécessaires
}
class MockRules: VerySimpleRules {
var mockMoves: [Move] = []
func getMoves(board: Board, owner: Owner) -> [Move] {
return mockMoves
}
}
class MockMove: Move {
// Implémentez les détails nécessaires
}
// Tests
class PlayerTests: XCTestCase {
func testPlayerInitialization() {
let player = Player(name: "TestPlayer", id: .player1)
XCTAssertNotNil(player)
XCTAssertEqual(player.name, "TestPlayer")
// Plus d'assertions pour id
}
}
class HumanPlayerTests: XCTestCase {
var mockBoard: MockBoard!
var mockRules: MockRules!
var mockMove: MockMove!
var rules: VerySimpleRules!
var board: Board!
override func setUp() {
super.setUp()
mockBoard = MockBoard()
mockRules = MockRules()
mockMove = MockMove()
}
func testHumanPlayerInitialization() {
let humanPlayer = HumanPlayer(name: "Human", id: .player1, inputMethod: { _, _ in return self.mockMove })
XCTAssertNotNil(humanPlayer)
XCTAssertEqual(humanPlayer.name, "Human")
rules = VerySimpleRules()
board = VerySimpleRules.createBoard()
}
func testHumanPlayerChooseMove() {
let humanPlayer = HumanPlayer(name: "Human", id: .player1, inputMethod: { _, _ in return self.mockMove })
let move = humanPlayer.chooseMove(board: mockBoard, rules: mockRules)
XCTAssertEqual(move, mockMove)
override func tearDown() {
rules = nil
board = nil
super.tearDown()
}
}
class RandomPlayerTests: XCTestCase {
var mockBoard: MockBoard!
var mockRules: MockRules!
var mockMove: MockMove!
func testRandomPlayerChooseMove() {
// Assurez-vous que l'initialisation de RandomPlayer correspond à votre implémentation
let randomPlayer = RandomPlayer(withName: "Random Player", andId: .player1)
XCTAssertNotNil(randomPlayer, "RandomPlayer n'a pas été correctement initialisé")
override func setUp() {
super.setUp()
mockBoard = MockBoard()
mockRules = MockRules()
mockMove = MockMove()
mockRules.mockMoves = [mockMove]
// Testez chooseMove avec le board et les règles réels
let move = randomPlayer?.chooseMove(board: board, rules: rules)
XCTAssertNotNil(move, "RandomPlayer n'a pas choisi de mouvement")
}
func testHumanPlayerChooseMove() {
// Assurez-vous que l'initialisation de HumanPlayer correspond à votre implémentation
let inputMethod: ([Move]) -> Move? = { moves in moves.first }
let humanPlayer = HumanPlayer(name: "Human Player", id: .player1, inputMethod: inputMethod)
XCTAssertNotNil(humanPlayer, "HumanPlayer n'a pas été correctement initialisé")
func testRandomPlayerInitialization() {
let randomPlayer = RandomPlayer(withName: "Random", andId: .player2)
XCTAssertNotNil(randomPlayer)
XCTAssertEqual(randomPlayer.name, "Random")
}
func testRandomPlayerChooseMove() {
let randomPlayer = RandomPlayer(withName: "Random", andId: .player2)
let move = randomPlayer.chooseMove(board: mockBoard, rules: mockRules)
XCTAssertNotNil(move)
// Testez chooseMove avec le board et les règles réels
let move = humanPlayer?.chooseMove(board: board, rules: rules)
XCTAssertNotNil(move, "HumanPlayer n'a pas choisi de mouvement")
}
}*/
}

127
Model/Tests/ModelTests/VerySimpleRulesTests.swift
Unescape View File

@ -57,62 +57,99 @@ class VerySimpleRulesTests: XCTestCase {
XCTAssertThrowsError(try VerySimpleRules.checkBoard(b: invalidBoard))
}
func testGetMoves() {
// Supposons que pour une configuration de plateau spécifique, vous attendiez 3 mouvements possibles pour le joueur 1
let expectedMoveCountForPlayer1 = 3 // Remplacez 3 par le nombre correct basé sur votre jeu
func testMoveValidation() {
// Testez un mouvement valide
let validMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1)
XCTAssertTrue(rules.isMoveValid(board: board, move: validMove), "Le mouvement valide n'a pas été reconnu comme tel")
// Testez un mouvement invalide
let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 3, columnDestination: 3)
XCTAssertFalse(rules.isMoveValid(board: board, move: invalidMove), "Le mouvement invalide a été reconnu comme valide")
}
func testGameProgression() {
// Effectuer un mouvement valide
let move = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1)
do {
try rules.playedMove(move: move, to: &board)
} catch {
XCTFail("Le mouvement n'a pas été appliqué comme prévu: \(error)")
}
// Test pour vérifier si getMoves retourne les bons mouvements pour le joueur 1
let movesForPlayer1 = rules.getMoves(board: board, owner: .player1)
// Vérifier que l'historique des mouvements a été mis à jour
XCTAssertEqual(rules.historic.count, 1, "L'historique des mouvements n'a pas été correctement mis à jour")
// XCTAssertEqual(movesForPlayer1.count, expectedMoveCountForPlayer1)
// Vérifier le changement de joueur
let nextPlayer = rules.getNextPlayer()
XCTAssertEqual(nextPlayer, .player2, "Le joueur suivant n'a pas été correctement mis à jour")
}
func testIsMoveValid() {
// Test pour un mouvement valide
let validMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 1, columnDestination: 0)
XCTAssertTrue(rules.isMoveValid(board: board, move: validMove))
// Test pour un mouvement invalide (par exemple, déplacement vers une case occupée par le même joueur)
let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 0, columnDestination: 1)
XCTAssertFalse(rules.isMoveValid(board: board, move: invalidMove))
func testGameProgressionWithInvalidMove() {
// Essayer d'effectuer un mouvement invalide
let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 3, columnDestination: 3)
XCTAssertThrowsError(try rules.playedMove(move: invalidMove, to: &board), "Un mouvement invalide a été accepté") { error in
guard let gameError = error as? GameError else {
XCTFail("Type d'erreur inattendu")
return
}
switch gameError {
case .invalidMove:
// Succès attendu, le mouvement est invalide
break
default:
XCTFail("Erreur inattendue pour un mouvement invalide")
}
}
}
func testIsGameOver() {
// Assurez-vous que `board` est bien initialisé
guard let currentBoard = board else {
XCTFail("Board is not initialized")
return
func testGameOverConditions() {
// Utiliser `isGameOver` pour vérifier l'état de fin de jeu
let (isOver, result) = rules.isGameOver(board: board, lastMove: Move(owner: .player1, rowOrigin: 0, columnOrigin: 2, rowDestination: 4, columnDestination: 2))
XCTAssertTrue(isOver, "Le jeu ne s'est pas terminé comme prévu")
// Vérifier le résultat du jeu
switch result {
case .winner(let owner, let reason):
XCTAssertEqual(owner, .player1, "Le mauvais joueur a été déclaré gagnant")
// Ajouter des assertions spécifiques pour la raison de la victoire si nécessaire
default:
XCTFail("Résultat de fin de jeu inattendu")
}
}
// Créez un mouvement qui simule une fin de partie
let winningMove = Move(owner: .player1, rowOrigin: 3, columnOrigin: 2, rowDestination: 4, columnDestination: 2)
/*
// Appliquez ce mouvement au plateau
// Cette partie dépend de la façon dont votre jeu applique les mouvements
// Ici, un exemple générique où nous remplaçons simplement la pièce dans la cellule de destination
if let piece = currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece {
currentBoard.grid[winningMove.rowDestination][winningMove.columnDestination].piece = piece
currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece = nil
}
*/
// Test pour obtenir une cellule spécifique du plateau
func testGetCell() {
let cell = board.getCell(atRow: 0, atColumn: 0)
XCTAssertNotNil(cell, "La cellule n'a pas été correctement récupérée")
}
// Testez si `isGameOver` détecte correctement la fin de partie
let (isGameOver, result) = rules.isGameOver(board: currentBoard, lastMove: winningMove)
// Test pour obtenir les mouvements possibles pour un joueur
func testGetMoves() {
// Supposons que le joueur 1 ait des mouvements valides depuis sa position initiale
let moves = rules.getMoves(board: board, owner: .player1)
XCTAssertFalse(moves.isEmpty, "Aucun mouvement possible trouvé pour le joueur 1")
}
XCTAssertTrue(isGameOver)
// Vérifiez le résultat spécifique de la fin de partie
switch result {
case .winner(let winner, let winCondition):
XCTAssertEqual(winner, .player1)
XCTAssertEqual(winCondition, .denReached)
default:
XCTFail("Unexpected game over result")
}
// Test pour vérifier le comportement de la fonction de mouvement
func testPlayedMove() {
// Assumer un mouvement valide
let move = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1)
XCTAssertNoThrow(try rules.playedMove(move: move, to: &board), "Le mouvement valide a provoqué une erreur")
// Vérifier l'état du plateau après le mouvement
let destinationCell = board.getCell(atRow: 1, atColumn: 1)
XCTAssertNotNil(destinationCell?.piece, "La pièce n'a pas été déplacée vers la nouvelle cellule")
XCTAssertEqual(destinationCell?.piece?.owner, .player1, "La pièce déplacée n'appartient pas au joueur 1")
}
// Test pour valider un mouvement spécifique en utilisant des coordonnées
func testIsMoveValidWithCoordinates() {
// Valider un mouvement en utilisant des coordonnées directes
XCTAssertTrue(rules.isMoveValid(board: board, row: 0, column: 1, rowArrived: 1, columnArrived: 1), "Le mouvement valide n'a pas été reconnu")
// Tester un mouvement invalide (par exemple, trop loin)
XCTAssertFalse(rules.isMoveValid(board: board, row: 0, column: 0, rowArrived: 3, columnArrived: 3), "Un mouvement invalide a été reconnu comme valide")
}
static var allTests = [
("testCreateBoard", testCreateBoard),
("testGetNextPlayer", testGetNextPlayer),
]
}

Write Preview
Loading…
Cancel
Save