From c2ee6ee2da3f3666fa9f7fafff1afebbe809cfd4 Mon Sep 17 00:00:00 2001
From: Rh17S15 <rh17s15@noreply.localhost>
Date: Mon, 22 Sep 2025 19:43:52 +0200
Subject: [PATCH] added mega unittests file test_unittest

---
 tests/test_unittest.py | 320 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 tests/test_unittest.py

diff --git a/tests/test_unittest.py b/tests/test_unittest.py
new file mode 100644
index 0000000..74e7282
--- /dev/null
+++ b/tests/test_unittest.py
@@ -0,0 +1,320 @@
+from model import Model
+import os.path
+from unittest.mock import Mock
+import unittest
+import tictactoe
+from model import Model
+from playerhandler import Playerhandler
+from minimax import Minimax
+
+from unittest.mock import patch
+
+
+class MockModel:
+    def check_move(self, x, y, verbose):
+        return True
+
+    def do_move(self, x, y, player1, player1_char, player2_char):
+        pass
+
+
+class MockPrinter:
+    # Define mock methods here that mimic the behavior of the Printer class...
+    def printfield(self, ifield):
+        pass  # Mock methods do nothing
+
+    def occupied(self):
+        pass
+
+    def aicalc(self):
+        pass
+
+    def aimoved(self, best_moev):
+        pass
+
+    def playermove(self, player1, player1_char, player2_char):
+        next_move = (0, 1)
+        return next_move
+
+
+class TestTicTacToe(unittest.TestCase):
+
+    def setUp(self):
+        self.game = tictactoe.Tictactoe()
+        self.printer = MockPrinter()
+        self.model = MockModel()
+    """
+    def test_turn(self):
+
+        # Test case 1: Player 1's turn, human player
+        player1_char = "X"
+        player2_char = "O"
+        player1 = True
+        ai = False
+        win = (1, 0)
+        field = [['O', '|', ' ', '|', 'X'],
+                 ['—', '+', '—', '+', '—'],
+                 [' ', '|', 'O', '|', 'X'],
+                 ['—', '+', '—', '+', '—'],
+                 ['O', '|', ' ', '|', ' ']]
+
+        # Mock the playermove method to return the desired next move
+        self.printer.playermove = lambda player, char1, char2: (1, 1)
+        #self.game.turn()
+        with patch('builtins.input', side_effect=['2', '2']):
+            self.game.turn()
+        self.assertEqual(field[4][4], player1_char)  # Player 1's move should be recorded
+
+        '''
+        # Test case 2: Player 2's turn, AI player
+        self.playerhandler.player1 = False
+        self.playerhandler.ai = True
+        self.model.field = [[' ', '|', 'O', '|', 'X'],
+                            ['—', '+', '—', '+', '—'],
+                            ['O', '|', 'X', '|', 'X'],
+                            ['—', '+', '—', '+', '—'],
+                            ['O', '|', ' ', '|', ' ']]
+
+        # Mock the aicalc method to return the desired best move
+        self.printer.aicalc = lambda: None
+        self.minimax.minimax = lambda field, player, char1, char2: (1, 0, 0)  # Mock the best move
+        self.turn()
+        self.assertEqual(self.model.field[0][1], self.playerhandler.player1_char)  # AI's move should be recorded
+        '''
+"""
+
+    def test_check_win(self) -> None:
+        player1_char = 'X'
+        player2_char = 'O'
+
+        # Testing player 1 win condition
+        field = [["X", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", " ", "|", " "]]
+
+        result = self.game.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (1, 0))
+
+        # Testing player 2 win condition
+        field = [["O", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", " ", "|", " "]]
+
+        result = self.game.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (0, 1))
+
+        # Testing draw condition
+        field = [["X", "|", "O", "|", "X"],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", "O", "|", "O"],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", "X", "|", "X"]]
+
+        result = self.game.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (1, 1))
+
+        # Testing no win condition
+        field = [[" ", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 [" ", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 [" ", "|", " ", "|", " "]]
+
+        result = self.game.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (0, 0))
+
+
+def test_play_game(self):
+    expected_result = True
+    # Call the method you want to test
+    result = self.tictactoe.play_game()
+    # Add assertions to check the result
+    self.assertEqual(result, expected_result)
+
+
+class TestMinimax(unittest.TestCase):
+    def setUp(self):
+        self.minimax = Minimax()  # Create an instance of your Minimax class
+
+    def test_minimax(self):
+        current_field = [["X", "|", " ", "|", " "],
+                         ["—", "+", "—", "+", "—"],
+                         [" ", "|", "X", "|", " "],
+                         ["—", "+", "—", "+", "—"],
+                         ["O", "|", "O", "|", " "]]  # Set the current field state
+        player1_char = 'X'
+        player2_char = 'O'
+
+        score, x, y = self.minimax.minimax(current_field, True, "X", "O")  # Call the minimax method
+        expected_score = 1  # Adjust the expected score based on the game rules and the field state
+        expected_x = 4  # Adjust the expected x-coordinate of the best move
+        expected_y = 4  # Adjust the expected y-coordinate of the best move
+
+        self.assertEqual(score, expected_score)  # Check if the score matches the expected value
+        self.assertEqual(x, expected_x)  # Check if the x-coordinate of the best move matches the expected value
+        self.assertEqual(y, expected_y)  # Check if the y-coordinate of the best move matches the expected value
+
+        current_field = [["X", "|", "O", "|", "X"],
+                         ["—", "+", "—", "+", "—"],
+                         [" ", "|", "O", "|", ""],
+                         ["—", "+", "—", "+", "—"],
+                         ["O", "|", " ", "|", "X"]]  # Set the current field state
+        player1_char = 'X'
+        player2_char = 'O'
+
+        score, x, y = self.minimax.minimax(current_field, True, "X", "O")  # Call the minimax method
+        expected_score = 1  # Adjust the expected score based on the game rules and the field state
+        expected_x = 2  # Adjust the expected x-coordinate of the best move
+        expected_y = 4  # Adjust the expected y-coordinate of the best move
+
+        self.assertEqual(score, expected_score)  # Check if the score matches the expected value
+        self.assertEqual(x, expected_x)  # Check if the x-coordinate of the best move matches the expected value
+        self.assertEqual(y, expected_y)  # Check if the y-coordinate of the best move matches the expected value
+
+    def test_check_win(self) -> None:
+        player1_char = 'X'
+        player2_char = 'O'
+
+        # Testing player 1 win condition
+        field = [["X", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", " ", "|", " "]]
+
+        result = self.minimax.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (1, 0))
+
+        # Testing player 2 win condition
+        field = [["O", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", " ", "|", " "]]
+
+        result = self.minimax.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (0, 1))
+
+        # Testing draw condition
+        field = [["X", "|", "O", "|", "X"],
+                 ["—", "+", "—", "+", "—"],
+                 ["X", "|", "O", "|", "O"],
+                 ["—", "+", "—", "+", "—"],
+                 ["O", "|", "X", "|", "X"]]
+
+        result = self.minimax.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (1, 1))
+
+        # Testing no win condition
+        field = [[" ", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 [" ", "|", " ", "|", " "],
+                 ["—", "+", "—", "+", "—"],
+                 [" ", "|", " ", "|", " "]]
+
+        result = self.minimax.check_win(field, player1_char, player2_char)
+        self.assertEqual(result, (0, 0))
+
+
+class TestModel(unittest.TestCase):
+    def setUp(self) -> None:
+        # self.model = model.Model()
+        self.field = [[" ", "|", " ", "|", " "],
+                      ["—", "+", "—", "+", "—"],
+                      [" ", "|", " ", "|", " "],
+                      ["—", "+", "—", "+", "—"],
+                      [" ", "|", " ", "|", " "]]
+        self.field2 = [["X", "|", " ", "|", " "],
+                       ["—", "+", "—", "+", "—"],
+                       [" ", "|", " ", "|", " "],
+                       ["—", "+", "—", "+", "—"],
+                       [" ", "|", " ", "|", " "]]
+        self.model = Model()  # Create an instance of your Model class
+
+    def tearDown(self):
+        if os.path.isfile('./savestate.py'):
+            os.remove("savestate.py")  # Remove the savestate file if it exists
+
+    def test_loadsavestate(self):
+        f = open("savestate.py", "w")  # Create a savestate file
+        f.write('save = [["X", "|", " ", "|", " "],'
+                '["—", "+", "—", "+", "—"],'
+                '[" ", "|", " ", "|", " "],'
+                '["—", "+", "—", "+", "—"],'
+                '[" ", "|", " ", "|", " "]]')
+        f.close()
+
+        self.model.loadsavestate()  # Call the loadsavestate method
+        expected_field = [["X", "|", " ", "|", " "],
+                          ["—", "+", "—", "+", "—"],
+                          [" ", "|", " ", "|", " "],
+                          ["—", "+", "—", "+", "—"],
+                          [" ", "|", " ", "|", " "]]
+        self.assertEqual(self.model.field, expected_field)  # Check if the field matches the expected state
+
+    def test_checksavestate(self):
+        self.assertFalse(self.model.checksavestate())  # Check if savestate does not exist
+
+        f = open("savestate.py", "w")  # Create a savestate file
+        f.write('save = [["X", "|", " ", "|", " "],'
+                '["—", "+", "—", "+", "—"],'
+                '[" ", "|", " ", "|", " "],'
+                '["—", "+", "—", "+", "—"],'
+                '[" ", "|", " ", "|", " "]]')
+        f.close()
+
+        self.assertTrue(self.model.checksavestate())  # Check if savestate exists
+
+    def test_savetosavestate(self):
+        self.model.field = [["X", "|", " ", "|", " "],
+                            ["—", "+", "—", "+", "—"],
+                            [" ", "|", " ", "|", " "],
+                            ["—", "+", "—", "+", "—"],
+                            [" ", "|", " ", "|", " "]]  # Set the field to a specific state
+
+        self.model.savetosavestate()  # Call the savetosavestate method
+
+        f = open("savestate.py", "r")  # Read the content of the savestate file
+        content = f.read()
+        f.close()
+
+        expected_content = "save = [['X', '|', ' ', '|', ' ']," \
+                           " ['—', '+', '—', '+', '—'], [' ', '|', ' ', '|', ' ']," \
+                           " ['—', '+', '—', '+', '—'], [' ', '|', ' ', '|', ' ']]"
+        self.assertEqual(content, expected_content)  # Check if the content matches the expected value
+
+    def test_deletesavestate(self):
+        f = open("savestate.py", "w")  # Create a savestate file
+        f.close()
+
+        self.model.deletesavestate()  # Call the deletesavestate method
+
+        self.assertFalse(os.path.isfile('./savestate.py'))  # Check if the savestate file does not exist
+
+    def test_check_move(self):
+        model = Model()  # Create an instance of your Model class
+        self.assertEqual(model.check_move(0, 0, True), True)
+
+    def test_do_move(self):
+        model = Model()  # Create an instance of your Model class
+        model.do_move(0, 0, True, "X", "O")  # Call the do_move method
+        expected_field = [["X", "|", " ", "|", " "],
+                          ["—", "+", "—", "+", "—"],
+                          [" ", "|", " ", "|", " "],
+                          ["—", "+", "—", "+", "—"],
+                          [" ", "|", " ", "|", " "]]
+        self.assertEqual(model.field, expected_field)
+
+
+if __name__ == '__main__':
+
+    unittest.main()
+    f = open("savestate.py", "r")  # Read the content of the savestate file
+    f.write("save = [['X', '|', ' ', '|', ' '], "
+            "['—', '+', '—', '+', '—'], [' ', '|', ' ', '|', ' '], "
+            "['—', '+', '—', '+', '—'], [' ', '|', ' ', '|', ' ']]")
+    f.close()