diff --git a/Model/Sources/Model/TicTacToeRules.swift b/Model/Sources/Model/TicTacToeRules.swift
index c3b3b63..1cd002b 100644
--- a/Model/Sources/Model/TicTacToeRules.swift
+++ b/Model/Sources/Model/TicTacToeRules.swift
@@ -20,56 +20,56 @@ public struct TicTacToeRules: Rules {
         self.piecesToAlign = piecesToAlign
     }
     
-        public func isGameOver(board: Board) -> (result: Bool, winner: Token) {
-                // Vérification générale avec le nombre de pièces à aligner
-                let maxRow = board.rowNb
-                let maxCol = board.columnNb
+    public func isGameOver(board: Board) -> (result: Bool, winner: Token) {
+            // Vérification générale avec le nombre de pièces à aligner
+            let maxRow = board.rowNb
+            let maxCol = board.columnNb
 
-                // Vérification horizontale
-                for row in 0..<maxRow {
-                    for col in 0..<(maxCol - piecesToAlign + 1) {
-                        if checkLine(board: board, start: (row, col), direction: (0, 1)) {
-                            return (true, board[row, col])
-                        }
+            // Vérification horizontale
+            for row in 0..<maxRow {
+                for col in 0..<(maxCol - piecesToAlign + 1) {
+                    if checkLine(board: board, start: (row, col), direction: (0, 1)) {
+                        return (true, board[row, col])
                     }
                 }
+            }
 
-                // Vérification verticale
-                for col in 0..<maxCol {
-                    for row in 0..<(maxRow - piecesToAlign + 1) {
-                        if checkLine(board: board, start: (row, col), direction: (1, 0)) {
-                            return (true, board[row, col])
-                        }
+            // Vérification verticale
+            for col in 0..<maxCol {
+                for row in 0..<(maxRow - piecesToAlign + 1) {
+                    if checkLine(board: board, start: (row, col), direction: (1, 0)) {
+                        return (true, board[row, col])
                     }
                 }
+            }
 
-                // Vérification diagonale ascendante (\)
-                for row in (piecesToAlign - 1)..<maxRow {
-                    for col in 0..<(maxCol - piecesToAlign + 1) {
-                        if checkLine(board: board, start: (row, col), direction: (-1, 1)) {
-                            return (true, board[row, col])
-                        }
+            // Vérification diagonale ascendante (\)
+            for row in (piecesToAlign - 1)..<maxRow {
+                for col in 0..<(maxCol - piecesToAlign + 1) {
+                    if checkLine(board: board, start: (row, col), direction: (-1, 1)) {
+                        return (true, board[row, col])
                     }
                 }
+            }
 
-                // Vérification diagonale descendante (/)
-                for row in 0..<(maxRow - piecesToAlign + 1) {
-                    for col in 0..<(maxCol - piecesToAlign + 1) {
-                        if checkLine(board: board, start: (row, col), direction: (1, 1)) {
-                            return (true, board[row, col])
-                        }
+            // Vérification diagonale descendante (/)
+            for row in 0..<(maxRow - piecesToAlign + 1) {
+                for col in 0..<(maxCol - piecesToAlign + 1) {
+                    if checkLine(board: board, start: (row, col), direction: (1, 1)) {
+                        return (true, board[row, col])
                     }
                 }
+            }
 
-                // Vérification du match nul (plateau plein)
-                for row in 0..<maxRow {
-                    for col in 0..<maxCol {
-                        if board[row, col] == .empty {
-                            return (false, Token.empty)
-                        }
+            // Vérification du match nul (plateau plein)
+            for row in 0..<maxRow {
+                for col in 0..<maxCol {
+                    if board[row, col] == .empty {
+                        return (false, Token.empty)
                     }
                 }
-            return (true, Token.empty)
+            }
+        return (true, Token.empty)
     }
     
     public func possibleMoves(board: Board) -> [Move] {
diff --git a/Model/Tests/ModelTests/Connect4Rules/IsGameOverTest.swift b/Model/Tests/ModelTests/Connect4Rules/IsGameOverTest.swift
index 0b3b00b..018d98c 100644
--- a/Model/Tests/ModelTests/Connect4Rules/IsGameOverTest.swift
+++ b/Model/Tests/ModelTests/Connect4Rules/IsGameOverTest.swift
@@ -21,22 +21,33 @@ final class IsGameOverTest: XCTestCase {
         XCTAssertTrue(rules.isGameOver(board: board).result)
         XCTAssertEqual(rules.isGameOver(board: board).winner, Token.red)
     }
-    /*func testFullGridWithoutWin() {
-        // A REVOIR
-        let rules = Connect4Rules(piecesToAlign: 4)
-        var board = Board()
+    func testFullGridWithoutWin() {
+        let rules = TicTacToeRules(piecesToAlign: 3)
+        var board = Board(rowsNb: 3, columnsNb: 3)
 
-        // Remplir une grille complète sans qu'il y ait de victoire
-        for row in 0..<board.rowNb {
-            for col in 0..<board.columnNb {
-                board[row, col] = (row + col) % 2 == 0 ? Token.red : Token.yellow
-            }
-        }
+        board[0, 1] = .yellow
+        board[0, 0] = .red
+        XCTAssertFalse(rules.isGameOver(board: board).result)
+        
+        board[1, 1] = .yellow
+        board[0, 2] = .red
+        XCTAssertFalse(rules.isGameOver(board: board).result)
+        
+        board[1, 2] = .yellow
+        board[1, 0] = .red
+        XCTAssertFalse(rules.isGameOver(board: board).result)
+        
+        board[2, 0] = .yellow
+        board[2, 1] = .red
+        XCTAssertFalse(rules.isGameOver(board: board).result)
+        
+        board[2, 2] = .yellow
 
         // Personne ne gagne, mais la partie est terminée
-        XCTAssertTrue(rules.isGameOver(board: board).result)
-        XCTAssertEqual(rules.isGameOver(board: board).winner, Token.empty)
-    }*/
+        let isGameOver = rules.isGameOver(board: board)
+        XCTAssertTrue(isGameOver.result)
+        XCTAssertEqual(isGameOver.winner, Token.empty)
+    }
     func testVertical() {
         let rules = Connect4Rules(piecesToAlign: 4)
         var board = Board()
@@ -53,46 +64,44 @@ final class IsGameOverTest: XCTestCase {
         board[3, 0] = Token.red
 
         // Le rouge gagne
-        XCTAssertTrue(rules.isGameOver(board: board).result)
-        XCTAssertEqual(rules.isGameOver(board: board).winner, Token.red)
+        let isGameOver = rules.isGameOver(board: board)
+        XCTAssertTrue(isGameOver.result)
+        XCTAssertEqual(isGameOver.winner, Token.red)
     }
-    /*func testDiagonalAscending() {
-        let rules = Connect4Rules(piecesToAlign: 4)
-        var board = Board()
+    func testDiagonalDescending() {
+        let rules = TicTacToeRules(piecesToAlign: 3)
+        var board = Board(rowsNb: 3, columnsNb: 3)
 
         // Placer les jetons pour une victoire diagonale ascendante
-        board[0, 0] = Token.red
-        board[1, 1] = Token.yellow
-        board[1, 0] = Token.red
-        board[2, 2] = Token.yellow
-        board[2, 1] = Token.red
-        board[3, 3] = Token.yellow
-        board[3, 2] = Token.red
-        board[3, 1] = Token.yellow
-        board[3, 0] = Token.red
+        board[2, 0] = Token.red
+        board[2, 1] = Token.yellow
+        
+        board[1, 1] = Token.red
+        board[0, 0] = Token.yellow
+        
+        board[0, 2] = Token.red
 
         // Rouge gagne ici
-        XCTAssertTrue(rules.isGameOver(board: board).result)
-        XCTAssertEqual(rules.isGameOver(board: board).winner, Token.red)
-    }*/
+        let isGameOver = rules.isGameOver(board: board)
+        XCTAssertTrue(isGameOver.result)
+        XCTAssertEqual(isGameOver.winner, Token.red)
+    }
 
-    /*func testDiagonalDescending() {
-        let rules = Connect4Rules(piecesToAlign: 4)
-        var board = Board()
+    func testDiagonalAscending() {
+        let rules = TicTacToeRules(piecesToAlign: 3)
+        var board = Board(rowsNb: 3, columnsNb: 3)
 
         // Placer les jetons pour une victoire diagonale descendante
-        board[3, 0] = Token.red
-        board[2, 1] = Token.yellow
-        board[2, 0] = Token.red
-        board[1, 2] = Token.yellow
-        board[1, 1] = Token.red
-        board[0, 3] = Token.yellow
-        board[0, 2] = Token.red
-        board[0, 1] = Token.yellow
-        board[0, 0] = Token.red
-
+        board[0, 2] = .yellow
+        board[1, 2] = .red
+        
+        board[1, 1] = .yellow
+        board[0, 0] = .red
+        
+        board[2, 0] = .yellow
         // Rouge gagne ici
-        XCTAssertTrue(rules.isGameOver(board: board).result)
-        XCTAssertEqual(rules.isGameOver(board: board).winner, Token.red)
-    }*/
+        let isGameOver = rules.isGameOver(board: board)
+        XCTAssertTrue(isGameOver.result)
+        XCTAssertEqual(isGameOver.winner, Token.yellow)
+    }
 }