import unittest
import os
import sys
from sudoku_file import Sudoku, solver_sudoku, main


obj = Sudoku()
file = os.path.join(os.path.dirname(__file__), 'Tests', 'Example4.txt')
game = [['.', '3', '.', '.', '.', '.', '5', '.', '.'],
        ['.', '.', '.', '4', '7', '2', '.', '.', '.'],
        ['9', '.', '8', '5', '.', '.', '.', '.', '.'],
        ['.', '.', '1', '.', '.', '8', '9', '.', '.'],
        ['.', '.', '.', '.', '2', '.', '.', '.', '.'],
        ['2', '.', '.', '.', '.', '.', '.', '4', '5'],
        ['.', '4', '.', '.', '3', '.', '1', '2', '.'],
        ['.', '.', '.', '.', '.', '6', '.', '.', '8'],
        ['.', '.', '.', '1', '9', '.', '.', '.', '7']]


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(
            ['9', '7', '8', '5', '3', '1', '6', '4', '2']), True)
        self.assertEqual(obj.check(
            [':', '7', '$', '5', '3', 'a', '6', '4', 'V']), False)

    def test_difference_of_lists(self):
        self.assertEqual(obj.remove_in_list(
            ['9', '7', '8', '5', '3', '1', '6', '4', '2'],
            ['.', '7', '.', '5', '3', '.', '6', '4', '2']),
            ['9', '8', '1'])

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions(
            [['4', '.', '3', '.', '.', '2', '.', '.', '.'],
             ['5', '.', '.', '.', '6', '.', '1', '2', '.'],
             ['9', '.', '.', '.', '.', '.', '.', '.', '4'],
             ['.', '.', '8', '.', '7', '.', '.', '.', '.'],
             ['.', '.', '.', '2', '.', '3', '.', '.', '8'],
             ['.', '3', '6', '.', '.', '.', '7', '.', '.'],
             ['.', '7', '.', '9', '2', '.', '.', '.', '.'],
             ['.', '.', '.', '.', '.', '5', '.', '9', '6'],
             ['.', '.', '.', '8', '.', '4', '5', '.', '.']]),
             (0, 1))
        self.assertEqual(obj.find_empty_positions(
            [['4', '6', '3', '1', '8', '2', '9', '7', '5'],
             ['5', '8', '7', '4', '6', '9', '1', '2', '3'],
             ['9', '2', '1', '3', '5', '7', '8', '6', '4'],
             ['2', '4', '8', '6', '7', '1', '3', '5', '9'],
             ['7', '5', '9', '2', '4', '3', '6', '1', '8'],
             ['1', '3', '6', '5', '9', '8', '7', '4', '2'],
             ['3', '7', '5', '9', '2', '6', '4', '8', '1'],
             ['8', '1', '4', '7', '3', '5', '2', '9', '6'],
             ['6', '9', '2', '8', '1', '4', '5', '3', '7']]),
             False)

    def test_groups(self):
        self.assertEqual(obj.groups(
            ['4', '5', '2', '3', '5'], 2), [['4', '5'], ['2', '3'], ['5']])

    def test_row(self):
        self.assertEqual(obj.num_in_row_where_pos(
            game, (3, 5)), ['.', '.', '1', '.', '.', '8', '9', '.', '.'])

    def test_column(self):
        self.assertEqual(obj.num_in_column_where_pos(game, (3, 5)),
                         ['.', '2', '.', '8', '.', '.', '.', '6', '.'])

    def test_square(self):
        self.assertEqual(obj.num_in_square_where_pos(game, (3, 5)),
                         ['.', '.', '8', '.', '2', '.', '.', '.', '.'])

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(
            game, (3, 4)), ['4', '5', '6'])
        self.assertEqual(obj.find_possible_values(
            game, (7, 1)), ['1', '2', '5', '7', '9'])

    def test_solve(self):
        self.assertEqual(obj.solve(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']])
        self.assertEqual(obj.solve(
            [['4', '.', '3', '.', '.', '2', '.', '.', '.'],
             ['5', '.', '.', '.', '6', '.', '1', '2', '.'],
             ['9', '.', '.', '.', '.', '.', '.', '.', '4'],
             ['.', '3', '8', '.', '7', '.', '.', '.', '.'],
             ['.', '.', '.', '2', '.', '3', '.', '.', '8'],
             ['.', '3', '6', '.', '.', '.', '7', '.', '.'],
             ['.', '7', '.', '9', '2', '.', '.', '.', '.'],
             ['.', '.', '.', '.', '.', '5', '.', '9', '6'],
             ['.', '.', '.', '8', '.', '4', '5', '.', '.']]),
             False)
        self.assertEqual(obj.solve(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '7', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '.', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             False)

    def test_check_solution(self):
        self.assertEqual(obj.check_solution(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '1', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             False)
        self.assertEqual(obj.check_solution(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             True)

    def test_input_sudoku(self):
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '5', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(game), True)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '1', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '1', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)

    def test_read_file(self):
        self.assertEqual(
            obj.read_from_file(file),
            [['8', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '.', '3', '6', '.', '.', '.', '.', '.'],
             ['.', '7', '.', '.', '9', '.', '2', '.', '.'],
             ['.', '5', '.', '.', '.', '7', '.', '.', '.'],
             ['.', '.', '.', '.', '4', '5', '7', '.', '.'],
             ['.', '.', '.', '1', '.', '.', '.', '3', '.'],
             ['.', '.', '1', '.', '.', '.', '.', '6', '8'],
             ['.', '.', '8', '5', '.', '.', '.', '1', '.'],
             ['.', '9', '.', '.', '.', '.', '4', '.', '.']])

    def test_output(self):
        self.assertEqual(obj.output(game), None)

    def test_solve_line(self):
        sys.argv = ['x', '......2.38.52.......31..4....2..1..5.586.231'
                    '.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x', '......2.38.52.......31..4....2..1'
                    '..5.586.231.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_main_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_main_line_error(self):
        sys.argv = ['x', '.2....2.38.52.......31..4....2..1..5'
                    '.586.231.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_exception(self):
        sys.argv = ['x', 'direct']
        self.assertIsNone(main())


if __name__ == '__main__':
    unittest.main()

01c777e685820a861a232842428646218444e5b4
<mask token>


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(['9', '7', '8', '5', '3', '1', '6', '4',
            '2']), True)
        self.assertEqual(obj.check([':', '7', '$', '5', '3', 'a', '6', '4',
            'V']), False)
    <mask token>

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions([['4', '.', '3', '.', '.',
            '2', '.', '.', '.'], ['5', '.', '.', '.', '6', '.', '1', '2',
            '.'], ['9', '.', '.', '.', '.', '.', '.', '.', '4'], ['.', '.',
            '8', '.', '7', '.', '.', '.', '.'], ['.', '.', '.', '2', '.',
            '3', '.', '.', '8'], ['.', '3', '6', '.', '.', '.', '7', '.',
            '.'], ['.', '7', '.', '9', '2', '.', '.', '.', '.'], ['.', '.',
            '.', '.', '.', '5', '.', '9', '6'], ['.', '.', '.', '8', '.',
            '4', '5', '.', '.']]), (0, 1))
        self.assertEqual(obj.find_empty_positions([['4', '6', '3', '1', '8',
            '2', '9', '7', '5'], ['5', '8', '7', '4', '6', '9', '1', '2',
            '3'], ['9', '2', '1', '3', '5', '7', '8', '6', '4'], ['2', '4',
            '8', '6', '7', '1', '3', '5', '9'], ['7', '5', '9', '2', '4',
            '3', '6', '1', '8'], ['1', '3', '6', '5', '9', '8', '7', '4',
            '2'], ['3', '7', '5', '9', '2', '6', '4', '8', '1'], ['8', '1',
            '4', '7', '3', '5', '2', '9', '6'], ['6', '9', '2', '8', '1',
            '4', '5', '3', '7']]), False)
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(game, (3, 4)), ['4', '5',
            '6'])
        self.assertEqual(obj.find_possible_values(game, (7, 1)), ['1', '2',
            '5', '7', '9'])
    <mask token>

    def test_check_solution(self):
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '1', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), False)
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '2', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), True)
    <mask token>

    def test_read_file(self):
        self.assertEqual(obj.read_from_file(file), [['8', '.', '.', '.',
            '.', '.', '.', '.', '.'], ['.', '.', '3', '6', '.', '.', '.',
            '.', '.'], ['.', '7', '.', '.', '9', '.', '2', '.', '.'], ['.',
            '5', '.', '.', '.', '7', '.', '.', '.'], ['.', '.', '.', '.',
            '4', '5', '7', '.', '.'], ['.', '.', '.', '1', '.', '.', '.',
            '3', '.'], ['.', '.', '1', '.', '.', '.', '.', '6', '8'], ['.',
            '.', '8', '5', '.', '.', '.', '1', '.'], ['.', '9', '.', '.',
            '.', '.', '4', '.', '.']])
    <mask token>
    <mask token>

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)
    <mask token>
    <mask token>
    <mask token>


<mask token>

<mask token>


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(['9', '7', '8', '5', '3', '1', '6', '4',
            '2']), True)
        self.assertEqual(obj.check([':', '7', '$', '5', '3', 'a', '6', '4',
            'V']), False)

    def test_difference_of_lists(self):
        self.assertEqual(obj.remove_in_list(['9', '7', '8', '5', '3', '1',
            '6', '4', '2'], ['.', '7', '.', '5', '3', '.', '6', '4', '2']),
            ['9', '8', '1'])

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions([['4', '.', '3', '.', '.',
            '2', '.', '.', '.'], ['5', '.', '.', '.', '6', '.', '1', '2',
            '.'], ['9', '.', '.', '.', '.', '.', '.', '.', '4'], ['.', '.',
            '8', '.', '7', '.', '.', '.', '.'], ['.', '.', '.', '2', '.',
            '3', '.', '.', '8'], ['.', '3', '6', '.', '.', '.', '7', '.',
            '.'], ['.', '7', '.', '9', '2', '.', '.', '.', '.'], ['.', '.',
            '.', '.', '.', '5', '.', '9', '6'], ['.', '.', '.', '8', '.',
            '4', '5', '.', '.']]), (0, 1))
        self.assertEqual(obj.find_empty_positions([['4', '6', '3', '1', '8',
            '2', '9', '7', '5'], ['5', '8', '7', '4', '6', '9', '1', '2',
            '3'], ['9', '2', '1', '3', '5', '7', '8', '6', '4'], ['2', '4',
            '8', '6', '7', '1', '3', '5', '9'], ['7', '5', '9', '2', '4',
            '3', '6', '1', '8'], ['1', '3', '6', '5', '9', '8', '7', '4',
            '2'], ['3', '7', '5', '9', '2', '6', '4', '8', '1'], ['8', '1',
            '4', '7', '3', '5', '2', '9', '6'], ['6', '9', '2', '8', '1',
            '4', '5', '3', '7']]), False)
    <mask token>

    def test_row(self):
        self.assertEqual(obj.num_in_row_where_pos(game, (3, 5)), ['.', '.',
            '1', '.', '.', '8', '9', '.', '.'])
    <mask token>

    def test_square(self):
        self.assertEqual(obj.num_in_square_where_pos(game, (3, 5)), ['.',
            '.', '8', '.', '2', '.', '.', '.', '.'])

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(game, (3, 4)), ['4', '5',
            '6'])
        self.assertEqual(obj.find_possible_values(game, (7, 1)), ['1', '2',
            '5', '7', '9'])

    def test_solve(self):
        self.assertEqual(obj.solve([['.', '.', '5', '.', '.', '.', '.', '.',
            '7'], ['6', '.', '.', '7', '.', '3', '.', '.', '5'], ['.', '.',
            '.', '.', '.', '.', '.', '.', '.'], ['.', '6', '.', '3', '.',
            '.', '1', '.', '.'], ['4', '.', '.', '.', '.', '.', '.', '.',
            '6'], ['.', '.', '2', '.', '.', '5', '.', '3', '.'], ['.', '3',
            '.', '.', '.', '9', '.', '.', '.'], ['9', '.', '.', '1', '.',
            '7', '6', '5', '.'], ['2', '.', '.', '.', '.', '.', '.', '.',
            '.']]), [['1', '2', '5', '4', '6', '8', '3', '9', '7'], ['6',
            '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7', '9', '2',
            '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8', '4', '1',
            '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8', '6'], ['8',
            '9', '2', '6', '1', '5', '7', '3', '4'], ['7', '3', '6', '5',
            '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3', '7', '6',
            '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7', '3']])
        self.assertEqual(obj.solve([['4', '.', '3', '.', '.', '2', '.', '.',
            '.'], ['5', '.', '.', '.', '6', '.', '1', '2', '.'], ['9', '.',
            '.', '.', '.', '.', '.', '.', '4'], ['.', '3', '8', '.', '7',
            '.', '.', '.', '.'], ['.', '.', '.', '2', '.', '3', '.', '.',
            '8'], ['.', '3', '6', '.', '.', '.', '7', '.', '.'], ['.', '7',
            '.', '9', '2', '.', '.', '.', '.'], ['.', '.', '.', '.', '.',
            '5', '.', '9', '6'], ['.', '.', '.', '8', '.', '4', '5', '.',
            '.']]), False)
        self.assertEqual(obj.solve([['1', '2', '5', '4', '6', '8', '3', '9',
            '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7',
            '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8',
            '4', '7', '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8',
            '6'], ['8', '9', '2', '6', '1', '5', '.', '3', '4'], ['7', '3',
            '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3',
            '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7',
            '3']]), False)

    def test_check_solution(self):
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '1', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), False)
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '2', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), True)
    <mask token>

    def test_read_file(self):
        self.assertEqual(obj.read_from_file(file), [['8', '.', '.', '.',
            '.', '.', '.', '.', '.'], ['.', '.', '3', '6', '.', '.', '.',
            '.', '.'], ['.', '7', '.', '.', '9', '.', '2', '.', '.'], ['.',
            '5', '.', '.', '.', '7', '.', '.', '.'], ['.', '.', '.', '.',
            '4', '5', '7', '.', '.'], ['.', '.', '.', '1', '.', '.', '.',
            '3', '.'], ['.', '.', '1', '.', '.', '.', '.', '6', '8'], ['.',
            '.', '8', '5', '.', '.', '.', '1', '.'], ['.', '9', '.', '.',
            '.', '.', '4', '.', '.']])
    <mask token>

    def test_solve_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_main_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_main_line_error(self):
        sys.argv = ['x',
            '.2....2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_exception(self):
        sys.argv = ['x', 'direct']
        self.assertIsNone(main())


<mask token>

<mask token>


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(['9', '7', '8', '5', '3', '1', '6', '4',
            '2']), True)
        self.assertEqual(obj.check([':', '7', '$', '5', '3', 'a', '6', '4',
            'V']), False)

    def test_difference_of_lists(self):
        self.assertEqual(obj.remove_in_list(['9', '7', '8', '5', '3', '1',
            '6', '4', '2'], ['.', '7', '.', '5', '3', '.', '6', '4', '2']),
            ['9', '8', '1'])

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions([['4', '.', '3', '.', '.',
            '2', '.', '.', '.'], ['5', '.', '.', '.', '6', '.', '1', '2',
            '.'], ['9', '.', '.', '.', '.', '.', '.', '.', '4'], ['.', '.',
            '8', '.', '7', '.', '.', '.', '.'], ['.', '.', '.', '2', '.',
            '3', '.', '.', '8'], ['.', '3', '6', '.', '.', '.', '7', '.',
            '.'], ['.', '7', '.', '9', '2', '.', '.', '.', '.'], ['.', '.',
            '.', '.', '.', '5', '.', '9', '6'], ['.', '.', '.', '8', '.',
            '4', '5', '.', '.']]), (0, 1))
        self.assertEqual(obj.find_empty_positions([['4', '6', '3', '1', '8',
            '2', '9', '7', '5'], ['5', '8', '7', '4', '6', '9', '1', '2',
            '3'], ['9', '2', '1', '3', '5', '7', '8', '6', '4'], ['2', '4',
            '8', '6', '7', '1', '3', '5', '9'], ['7', '5', '9', '2', '4',
            '3', '6', '1', '8'], ['1', '3', '6', '5', '9', '8', '7', '4',
            '2'], ['3', '7', '5', '9', '2', '6', '4', '8', '1'], ['8', '1',
            '4', '7', '3', '5', '2', '9', '6'], ['6', '9', '2', '8', '1',
            '4', '5', '3', '7']]), False)
    <mask token>

    def test_row(self):
        self.assertEqual(obj.num_in_row_where_pos(game, (3, 5)), ['.', '.',
            '1', '.', '.', '8', '9', '.', '.'])

    def test_column(self):
        self.assertEqual(obj.num_in_column_where_pos(game, (3, 5)), ['.',
            '2', '.', '8', '.', '.', '.', '6', '.'])

    def test_square(self):
        self.assertEqual(obj.num_in_square_where_pos(game, (3, 5)), ['.',
            '.', '8', '.', '2', '.', '.', '.', '.'])

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(game, (3, 4)), ['4', '5',
            '6'])
        self.assertEqual(obj.find_possible_values(game, (7, 1)), ['1', '2',
            '5', '7', '9'])

    def test_solve(self):
        self.assertEqual(obj.solve([['.', '.', '5', '.', '.', '.', '.', '.',
            '7'], ['6', '.', '.', '7', '.', '3', '.', '.', '5'], ['.', '.',
            '.', '.', '.', '.', '.', '.', '.'], ['.', '6', '.', '3', '.',
            '.', '1', '.', '.'], ['4', '.', '.', '.', '.', '.', '.', '.',
            '6'], ['.', '.', '2', '.', '.', '5', '.', '3', '.'], ['.', '3',
            '.', '.', '.', '9', '.', '.', '.'], ['9', '.', '.', '1', '.',
            '7', '6', '5', '.'], ['2', '.', '.', '.', '.', '.', '.', '.',
            '.']]), [['1', '2', '5', '4', '6', '8', '3', '9', '7'], ['6',
            '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7', '9', '2',
            '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8', '4', '1',
            '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8', '6'], ['8',
            '9', '2', '6', '1', '5', '7', '3', '4'], ['7', '3', '6', '5',
            '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3', '7', '6',
            '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7', '3']])
        self.assertEqual(obj.solve([['4', '.', '3', '.', '.', '2', '.', '.',
            '.'], ['5', '.', '.', '.', '6', '.', '1', '2', '.'], ['9', '.',
            '.', '.', '.', '.', '.', '.', '4'], ['.', '3', '8', '.', '7',
            '.', '.', '.', '.'], ['.', '.', '.', '2', '.', '3', '.', '.',
            '8'], ['.', '3', '6', '.', '.', '.', '7', '.', '.'], ['.', '7',
            '.', '9', '2', '.', '.', '.', '.'], ['.', '.', '.', '.', '.',
            '5', '.', '9', '6'], ['.', '.', '.', '8', '.', '4', '5', '.',
            '.']]), False)
        self.assertEqual(obj.solve([['1', '2', '5', '4', '6', '8', '3', '9',
            '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7',
            '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8',
            '4', '7', '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8',
            '6'], ['8', '9', '2', '6', '1', '5', '.', '3', '4'], ['7', '3',
            '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3',
            '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7',
            '3']]), False)

    def test_check_solution(self):
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '1', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), False)
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '2', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), True)

    def test_input_sudoku(self):
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5'], ['2', '.', '.', '.', '.', '.',
            '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '5', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku(game), True)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '1', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '1', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)

    def test_read_file(self):
        self.assertEqual(obj.read_from_file(file), [['8', '.', '.', '.',
            '.', '.', '.', '.', '.'], ['.', '.', '3', '6', '.', '.', '.',
            '.', '.'], ['.', '7', '.', '.', '9', '.', '2', '.', '.'], ['.',
            '5', '.', '.', '.', '7', '.', '.', '.'], ['.', '.', '.', '.',
            '4', '5', '7', '.', '.'], ['.', '.', '.', '1', '.', '.', '.',
            '3', '.'], ['.', '.', '1', '.', '.', '.', '.', '6', '8'], ['.',
            '.', '8', '5', '.', '.', '.', '1', '.'], ['.', '9', '.', '.',
            '.', '.', '4', '.', '.']])

    def test_output(self):
        self.assertEqual(obj.output(game), None)

    def test_solve_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_main_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_main_line_error(self):
        sys.argv = ['x',
            '.2....2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_exception(self):
        sys.argv = ['x', 'direct']
        self.assertIsNone(main())


<mask token>

<mask token>
obj = Sudoku()
file = os.path.join(os.path.dirname(__file__), 'Tests', 'Example4.txt')
game = [['.', '3', '.', '.', '.', '.', '5', '.', '.'], ['.', '.', '.', '4',
    '7', '2', '.', '.', '.'], ['9', '.', '8', '5', '.', '.', '.', '.', '.'],
    ['.', '.', '1', '.', '.', '8', '9', '.', '.'], ['.', '.', '.', '.', '2',
    '.', '.', '.', '.'], ['2', '.', '.', '.', '.', '.', '.', '4', '5'], [
    '.', '4', '.', '.', '3', '.', '1', '2', '.'], ['.', '.', '.', '.', '.',
    '6', '.', '.', '8'], ['.', '.', '.', '1', '9', '.', '.', '.', '7']]


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(['9', '7', '8', '5', '3', '1', '6', '4',
            '2']), True)
        self.assertEqual(obj.check([':', '7', '$', '5', '3', 'a', '6', '4',
            'V']), False)

    def test_difference_of_lists(self):
        self.assertEqual(obj.remove_in_list(['9', '7', '8', '5', '3', '1',
            '6', '4', '2'], ['.', '7', '.', '5', '3', '.', '6', '4', '2']),
            ['9', '8', '1'])

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions([['4', '.', '3', '.', '.',
            '2', '.', '.', '.'], ['5', '.', '.', '.', '6', '.', '1', '2',
            '.'], ['9', '.', '.', '.', '.', '.', '.', '.', '4'], ['.', '.',
            '8', '.', '7', '.', '.', '.', '.'], ['.', '.', '.', '2', '.',
            '3', '.', '.', '8'], ['.', '3', '6', '.', '.', '.', '7', '.',
            '.'], ['.', '7', '.', '9', '2', '.', '.', '.', '.'], ['.', '.',
            '.', '.', '.', '5', '.', '9', '6'], ['.', '.', '.', '8', '.',
            '4', '5', '.', '.']]), (0, 1))
        self.assertEqual(obj.find_empty_positions([['4', '6', '3', '1', '8',
            '2', '9', '7', '5'], ['5', '8', '7', '4', '6', '9', '1', '2',
            '3'], ['9', '2', '1', '3', '5', '7', '8', '6', '4'], ['2', '4',
            '8', '6', '7', '1', '3', '5', '9'], ['7', '5', '9', '2', '4',
            '3', '6', '1', '8'], ['1', '3', '6', '5', '9', '8', '7', '4',
            '2'], ['3', '7', '5', '9', '2', '6', '4', '8', '1'], ['8', '1',
            '4', '7', '3', '5', '2', '9', '6'], ['6', '9', '2', '8', '1',
            '4', '5', '3', '7']]), False)

    def test_groups(self):
        self.assertEqual(obj.groups(['4', '5', '2', '3', '5'], 2), [['4',
            '5'], ['2', '3'], ['5']])

    def test_row(self):
        self.assertEqual(obj.num_in_row_where_pos(game, (3, 5)), ['.', '.',
            '1', '.', '.', '8', '9', '.', '.'])

    def test_column(self):
        self.assertEqual(obj.num_in_column_where_pos(game, (3, 5)), ['.',
            '2', '.', '8', '.', '.', '.', '6', '.'])

    def test_square(self):
        self.assertEqual(obj.num_in_square_where_pos(game, (3, 5)), ['.',
            '.', '8', '.', '2', '.', '.', '.', '.'])

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(game, (3, 4)), ['4', '5',
            '6'])
        self.assertEqual(obj.find_possible_values(game, (7, 1)), ['1', '2',
            '5', '7', '9'])

    def test_solve(self):
        self.assertEqual(obj.solve([['.', '.', '5', '.', '.', '.', '.', '.',
            '7'], ['6', '.', '.', '7', '.', '3', '.', '.', '5'], ['.', '.',
            '.', '.', '.', '.', '.', '.', '.'], ['.', '6', '.', '3', '.',
            '.', '1', '.', '.'], ['4', '.', '.', '.', '.', '.', '.', '.',
            '6'], ['.', '.', '2', '.', '.', '5', '.', '3', '.'], ['.', '3',
            '.', '.', '.', '9', '.', '.', '.'], ['9', '.', '.', '1', '.',
            '7', '6', '5', '.'], ['2', '.', '.', '.', '.', '.', '.', '.',
            '.']]), [['1', '2', '5', '4', '6', '8', '3', '9', '7'], ['6',
            '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7', '9', '2',
            '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8', '4', '1',
            '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8', '6'], ['8',
            '9', '2', '6', '1', '5', '7', '3', '4'], ['7', '3', '6', '5',
            '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3', '7', '6',
            '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7', '3']])
        self.assertEqual(obj.solve([['4', '.', '3', '.', '.', '2', '.', '.',
            '.'], ['5', '.', '.', '.', '6', '.', '1', '2', '.'], ['9', '.',
            '.', '.', '.', '.', '.', '.', '4'], ['.', '3', '8', '.', '7',
            '.', '.', '.', '.'], ['.', '.', '.', '2', '.', '3', '.', '.',
            '8'], ['.', '3', '6', '.', '.', '.', '7', '.', '.'], ['.', '7',
            '.', '9', '2', '.', '.', '.', '.'], ['.', '.', '.', '.', '.',
            '5', '.', '9', '6'], ['.', '.', '.', '8', '.', '4', '5', '.',
            '.']]), False)
        self.assertEqual(obj.solve([['1', '2', '5', '4', '6', '8', '3', '9',
            '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'], ['3', '7',
            '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7', '3', '8',
            '4', '7', '2', '9'], ['4', '1', '3', '9', '7', '2', '5', '8',
            '6'], ['8', '9', '2', '6', '1', '5', '.', '3', '4'], ['7', '3',
            '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4', '1', '3',
            '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6', '9', '7',
            '3']]), False)

    def test_check_solution(self):
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '1', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), False)
        self.assertEqual(obj.check_solution([['1', '2', '5', '4', '6', '8',
            '3', '9', '7'], ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
            ['3', '7', '9', '2', '5', '1', '4', '6', '8'], ['5', '6', '7',
            '3', '8', '4', '1', '2', '9'], ['4', '1', '3', '9', '7', '2',
            '5', '8', '6'], ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
            ['7', '3', '6', '5', '2', '9', '8', '4', '1'], ['9', '8', '4',
            '1', '3', '7', '6', '5', '2'], ['2', '5', '1', '8', '4', '6',
            '9', '7', '3']]), True)

    def test_input_sudoku(self):
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5'], ['2', '.', '.', '.', '.', '.',
            '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '5', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku(game), True)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '1', '1', '.', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)
        self.assertEqual(obj.check_input_sudoku([['.', '.', '5', '.', '.',
            '.', '.', '.', '7'], ['6', '.', '.', '7', '.', '3', '.', '.',
            '5'], ['.', '.', '.', '.', '.', '.', '.', '.', '.'], ['.', '6',
            '.', '3', '.', '.', '1', '1', '.'], ['4', '.', '.', '.', '.',
            '.', '.', '.', '6'], ['.', '.', '2', '.', '.', '5', '.', '3',
            '.'], ['.', '3', '.', '.', '.', '9', '.', '.', '.'], ['9', '.',
            '.', '1', '.', '7', '6', '5', '.'], ['2', '.', '.', '.', '.',
            '.', '.', '.', '.']]), False)

    def test_read_file(self):
        self.assertEqual(obj.read_from_file(file), [['8', '.', '.', '.',
            '.', '.', '.', '.', '.'], ['.', '.', '3', '6', '.', '.', '.',
            '.', '.'], ['.', '7', '.', '.', '9', '.', '2', '.', '.'], ['.',
            '5', '.', '.', '.', '7', '.', '.', '.'], ['.', '.', '.', '.',
            '4', '5', '7', '.', '.'], ['.', '.', '.', '1', '.', '.', '.',
            '3', '.'], ['.', '.', '1', '.', '.', '.', '.', '6', '8'], ['.',
            '.', '8', '5', '.', '.', '.', '1', '.'], ['.', '9', '.', '.',
            '.', '.', '4', '.', '.']])

    def test_output(self):
        self.assertEqual(obj.output(game), None)

    def test_solve_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x',
            '......2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_main_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_main_line_error(self):
        sys.argv = ['x',
            '.2....2.38.52.......31..4....2..1..5.586.231.3..9..6....4..85.......39.89.1......'
            ]
        self.assertEqual(solver_sudoku(), None)

    def test_exception(self):
        sys.argv = ['x', 'direct']
        self.assertIsNone(main())


if __name__ == '__main__':
    unittest.main()

import unittest
import os
import sys
from sudoku_file import Sudoku, solver_sudoku, main


obj = Sudoku()
file = os.path.join(os.path.dirname(__file__), 'Tests', 'Example4.txt')
game = [['.', '3', '.', '.', '.', '.', '5', '.', '.'],
        ['.', '.', '.', '4', '7', '2', '.', '.', '.'],
        ['9', '.', '8', '5', '.', '.', '.', '.', '.'],
        ['.', '.', '1', '.', '.', '8', '9', '.', '.'],
        ['.', '.', '.', '.', '2', '.', '.', '.', '.'],
        ['2', '.', '.', '.', '.', '.', '.', '4', '5'],
        ['.', '4', '.', '.', '3', '.', '1', '2', '.'],
        ['.', '.', '.', '.', '.', '6', '.', '.', '8'],
        ['.', '.', '.', '1', '9', '.', '.', '.', '7']]


class TestSudoku(unittest.TestCase):

    def test_check_number(self):
        self.assertEqual(obj.check(
            ['9', '7', '8', '5', '3', '1', '6', '4', '2']), True)
        self.assertEqual(obj.check(
            [':', '7', '$', '5', '3', 'a', '6', '4', 'V']), False)

    def test_difference_of_lists(self):
        self.assertEqual(obj.remove_in_list(
            ['9', '7', '8', '5', '3', '1', '6', '4', '2'],
            ['.', '7', '.', '5', '3', '.', '6', '4', '2']),
            ['9', '8', '1'])

    def test_find_empty_pos(self):
        self.assertEqual(obj.find_empty_positions(
            [['4', '.', '3', '.', '.', '2', '.', '.', '.'],
             ['5', '.', '.', '.', '6', '.', '1', '2', '.'],
             ['9', '.', '.', '.', '.', '.', '.', '.', '4'],
             ['.', '.', '8', '.', '7', '.', '.', '.', '.'],
             ['.', '.', '.', '2', '.', '3', '.', '.', '8'],
             ['.', '3', '6', '.', '.', '.', '7', '.', '.'],
             ['.', '7', '.', '9', '2', '.', '.', '.', '.'],
             ['.', '.', '.', '.', '.', '5', '.', '9', '6'],
             ['.', '.', '.', '8', '.', '4', '5', '.', '.']]),
             (0, 1))
        self.assertEqual(obj.find_empty_positions(
            [['4', '6', '3', '1', '8', '2', '9', '7', '5'],
             ['5', '8', '7', '4', '6', '9', '1', '2', '3'],
             ['9', '2', '1', '3', '5', '7', '8', '6', '4'],
             ['2', '4', '8', '6', '7', '1', '3', '5', '9'],
             ['7', '5', '9', '2', '4', '3', '6', '1', '8'],
             ['1', '3', '6', '5', '9', '8', '7', '4', '2'],
             ['3', '7', '5', '9', '2', '6', '4', '8', '1'],
             ['8', '1', '4', '7', '3', '5', '2', '9', '6'],
             ['6', '9', '2', '8', '1', '4', '5', '3', '7']]),
             False)

    def test_groups(self):
        self.assertEqual(obj.groups(
            ['4', '5', '2', '3', '5'], 2), [['4', '5'], ['2', '3'], ['5']])

    def test_row(self):
        self.assertEqual(obj.num_in_row_where_pos(
            game, (3, 5)), ['.', '.', '1', '.', '.', '8', '9', '.', '.'])

    def test_column(self):
        self.assertEqual(obj.num_in_column_where_pos(game, (3, 5)),
                         ['.', '2', '.', '8', '.', '.', '.', '6', '.'])

    def test_square(self):
        self.assertEqual(obj.num_in_square_where_pos(game, (3, 5)),
                         ['.', '.', '8', '.', '2', '.', '.', '.', '.'])

    def test_poss_values(self):
        self.assertEqual(obj.find_possible_values(
            game, (3, 4)), ['4', '5', '6'])
        self.assertEqual(obj.find_possible_values(
            game, (7, 1)), ['1', '2', '5', '7', '9'])

    def test_solve(self):
        self.assertEqual(obj.solve(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']])
        self.assertEqual(obj.solve(
            [['4', '.', '3', '.', '.', '2', '.', '.', '.'],
             ['5', '.', '.', '.', '6', '.', '1', '2', '.'],
             ['9', '.', '.', '.', '.', '.', '.', '.', '4'],
             ['.', '3', '8', '.', '7', '.', '.', '.', '.'],
             ['.', '.', '.', '2', '.', '3', '.', '.', '8'],
             ['.', '3', '6', '.', '.', '.', '7', '.', '.'],
             ['.', '7', '.', '9', '2', '.', '.', '.', '.'],
             ['.', '.', '.', '.', '.', '5', '.', '9', '6'],
             ['.', '.', '.', '8', '.', '4', '5', '.', '.']]),
             False)
        self.assertEqual(obj.solve(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '7', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '.', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             False)

    def test_check_solution(self):
        self.assertEqual(obj.check_solution(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '1', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             False)
        self.assertEqual(obj.check_solution(
            [['1', '2', '5', '4', '6', '8', '3', '9', '7'],
             ['6', '4', '8', '7', '9', '3', '2', '1', '5'],
             ['3', '7', '9', '2', '5', '1', '4', '6', '8'],
             ['5', '6', '7', '3', '8', '4', '1', '2', '9'],
             ['4', '1', '3', '9', '7', '2', '5', '8', '6'],
             ['8', '9', '2', '6', '1', '5', '7', '3', '4'],
             ['7', '3', '6', '5', '2', '9', '8', '4', '1'],
             ['9', '8', '4', '1', '3', '7', '6', '5', '2'],
             ['2', '5', '1', '8', '4', '6', '9', '7', '3']]),
             True)

    def test_input_sudoku(self):
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '5', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(game), True)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '1', '1', '.', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)
        self.assertEqual(obj.check_input_sudoku(
            [['.', '.', '5', '.', '.', '.', '.', '.', '7'],
             ['6', '.', '.', '7', '.', '3', '.', '.', '5'],
             ['.', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '6', '.', '3', '.', '.', '1', '1', '.'],
             ['4', '.', '.', '.', '.', '.', '.', '.', '6'],
             ['.', '.', '2', '.', '.', '5', '.', '3', '.'],
             ['.', '3', '.', '.', '.', '9', '.', '.', '.'],
             ['9', '.', '.', '1', '.', '7', '6', '5', '.'],
             ['2', '.', '.', '.', '.', '.', '.', '.', '.']]),
             False)

    def test_read_file(self):
        self.assertEqual(
            obj.read_from_file(file),
            [['8', '.', '.', '.', '.', '.', '.', '.', '.'],
             ['.', '.', '3', '6', '.', '.', '.', '.', '.'],
             ['.', '7', '.', '.', '9', '.', '2', '.', '.'],
             ['.', '5', '.', '.', '.', '7', '.', '.', '.'],
             ['.', '.', '.', '.', '4', '5', '7', '.', '.'],
             ['.', '.', '.', '1', '.', '.', '.', '3', '.'],
             ['.', '.', '1', '.', '.', '.', '.', '6', '8'],
             ['.', '.', '8', '5', '.', '.', '.', '1', '.'],
             ['.', '9', '.', '.', '.', '.', '4', '.', '.']])

    def test_output(self):
        self.assertEqual(obj.output(game), None)

    def test_solve_line(self):
        sys.argv = ['x', '......2.38.52.......31..4....2..1..5.586.231'
                    '.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_solve_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_help(self):
        sys.argv = ['x', 'help']
        self.assertIsNone(main())

    def test_main_line(self):
        sys.argv = ['x', '......2.38.52.......31..4....2..1'
                    '..5.586.231.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_main_file(self):
        sys.argv = ['x', file]
        self.assertIsNone(solver_sudoku())

    def test_main_line_error(self):
        sys.argv = ['x', '.2....2.38.52.......31..4....2..1..5'
                    '.586.231.3..9..6....4..85.......39.89.1......']
        self.assertEqual(solver_sudoku(), None)

    def test_exception(self):
        sys.argv = ['x', 'direct']
        self.assertIsNone(main())


if __name__ == '__main__':
    unittest.main()
