require 'test/unit'
require 'Game'
class GameTest < Test::Unit::TestCase
  def setup   
    @expected_solution = [
    3,4,5, 9,8,7, 6,2,1, #8
    1,9,2, 6,5,4, 3,8,7, #17
    8,7,6, 3,2,1, 5,4,9, #26
    
    5,2,9, 8,1,6, 4,7,3, #35
    4,3,1, 7,9,2, 8,5,6, #44
    6,8,7, 5,4,3, 1,9,2, #53
        
    2,5,3, 4,6,9, 7,1,8, #62
    7,1,8, 2,3,5, 9,6,4, #71
    9,6,4, 1,7,8, 2,3,5] #80
  end
  
  def test_get_square
    game = Game.new(@expected_solution)
    exp_sq = [3,4,5,1,9,2,8,7,6]
    assert_equal(exp_sq, game.get_square(1))
    exp_sq = [9,8,7,6,5,4,3,2,1]
    assert_equal(exp_sq, game.get_square(2))
    exp_sq = [6,2,1,3,8,7,5,4,9]
    assert_equal(exp_sq, game.get_square(3))
    exp_sq = [5,2,9,4,3,1,6,8,7]
    assert_equal(exp_sq, game.get_square(4))
    exp_sq = [8,1,6,7,9,2,5,4,3]
    assert_equal(exp_sq, game.get_square(5))
    exp_sq = [4,7,3,8,5,6,1,9,2]
    assert_equal(exp_sq, game.get_square(6))
    exp_sq = [2,5,3,7,1,8,9,6,4]
    assert_equal(exp_sq, game.get_square(7))
    exp_sq = [4,6,9,2,3,5,1,7,8]
    assert_equal(exp_sq, game.get_square(8))
    exp_sq = [7,1,8,9,6,4,2,3,5]
    assert_equal(exp_sq, game.get_square(9))
  end
  
  def test_rows
    game_board = [
    3,4,5, 9,8,7, 6,2,1, #0-8
    1,9,2, 6,5,4, 3,8,7, #9-17
    8,7,6, 3,2,1, 5,4,9, #18-26
    
    5,2,9, 8,1,6, 4,7,3, #27-35
    4,3,1, 7,9,2, 8,5,6, #36-44
    6,8,7, 5,4,3, 1,9,2, #45-53
        
    2,5,3, 4,6,9, 7,1,8, #54-62
    7,1,8, 2,3,5, 9,6,4, #63-71
    9,6,4, 1,7,8, 2,3,5] #72-80
    
    (0..80).each do |i|
      val = game_board[i]
      game_board[i] = 0
      game = Game.new(game_board)
      pv = game.get_poss_row_vals(i)
      assert_equal(1, pv.length)
      assert_equal([val], pv)
      game_board[i] = val
      assert_equal(@expected_solution, game_board)
    end
  end
  
  def test_cols
    game_board = [
    3,4,5, 9,8,7, 6,2,1, #0-8
    1,9,2, 6,5,4, 3,8,7, #9-17
    8,7,6, 3,2,1, 5,4,9, #18-26
    
    5,2,9, 8,1,6, 4,7,3, #27-35
    4,3,1, 7,9,2, 8,5,6, #36-44
    6,8,7, 5,4,3, 1,9,2, #45-53
        
    2,5,3, 4,6,9, 7,1,8, #54-62
    7,1,8, 2,3,5, 9,6,4, #63-71
    9,6,4, 1,7,8, 2,3,5] #72-80
    
    (0..80).each do |i|
      val = game_board[i]
      game_board[i] = 0
      game = Game.new(game_board)
      pv = game.get_poss_col_vals(i)
      assert_equal(1, pv.length)
      assert_equal([val], pv)
      game_board[i] = val
      assert_equal(@expected_solution, game_board)
    end
  end
  
  def test_squares
    game_board = [
    3,4,5, 9,8,7, 6,2,1, #0-8
    1,9,2, 6,5,4, 3,8,7, #9-17
    8,7,6, 3,2,1, 5,4,9, #18-26
    
    5,2,9, 8,1,6, 4,7,3, #27-35
    4,3,1, 7,9,2, 8,5,6, #36-44
    6,8,7, 5,4,3, 1,9,2, #45-53
        
    2,5,3, 4,6,9, 7,1,8, #54-62
    7,1,8, 2,3,5, 9,6,4, #63-71
    9,6,4, 1,7,8, 2,3,5] #72-80
    
    (0..80).each do |i|
      val = game_board[i]
      game_board[i] = 0
      game = Game.new(game_board)
      pv = game.get_poss_sqr_vals(i)
      assert_equal(1, pv.length)
      assert_equal([val], pv)
      game_board[i] = val
      assert_equal(@expected_solution, game_board)
    end
  end
  
  def test_get_pv
    partial_solved_game = [
      3,0,5, 0,8,0, 6,2,0,
      0,0,0, 0,0,0, 0,0,0,
      0,0,0, 3,2,1, 0,4,9,
      
      5,2,9, 8,1,0, 4,0,0,
      0,0,0, 0,0,0, 0,0,0,
      0,0,7, 0,0,3, 1,9,2,
      
      2,5,0, 4,6,9, 0,0,0,
      0,0,0, 0,0,0, 0,0,0,
      9,6,4, 1,7,8, 2,3,5]
      game = Game.new(partial_solved_game)
      assert_equal([1,3,4,6,7,8], game.get_poss_col_vals(35))
      assert_equal([3,6,7], game.get_poss_row_vals(35))
      assert_equal([3,5,6,7,8], game.get_poss_sqr_vals(35))
      assert_equal([6,7], game.get_pv_for_row(35))
      assert_equal([1,3,4,6,7,8], game.get_pv_for_col(35))
      assert_equal([3,5,6,7,8], game.get_pv_for_sqr(35))
  end

  def test_solve_simple_game
    simple_game = [
    0,4,5, 9,8,7, 6,2,1,
    1,9,2, 6,5,4, 3,8,7,
    8,7,6, 3,2,1, 5,4,9,
    
    5,2,9, 8,1,6, 4,7,3,
    4,3,1, 7,9,2, 8,5,6,
    6,8,7, 5,4,3, 1,9,2,
        
    2,5,3, 4,6,9, 7,1,8,
    7,1,8, 2,3,5, 9,6,4,
    9,6,4, 1,7,8, 2,3,5]
    game = Game.new(simple_game)
    game.solve()
    assert(game.is_solved?)
    assert_equal(@expected_solution, game.board)
  end
  
  def test_solve_simple_game2
    simple_game2 = [
    3,4,5, 9,8,7, 6,2,1,
    1,9,2, 6,5,4, 3,8,7,
    8,7,0, 3,2,1, 5,4,9,
    
    5,2,9, 8,1,6, 4,7,3,
    4,3,1, 7,9,2, 8,5,6,
    6,8,7, 5,4,3, 1,9,2,
        
    2,5,3, 4,6,9, 7,1,8,
    7,1,8, 2,3,5, 9,6,4,
    9,6,4, 1,7,8, 2,3,5]
    game = Game.new(simple_game2)
    game.solve()
    assert(game.is_solved?)
    assert_equal(@expected_solution, game.board)
  end
  
  def test_solve_complex_game
    complex_game = [
    0,4,5, 9,8,7, 6,2,1,
    1,9,2, 6,5,4, 3,8,7,
    8,7,0, 3,2,1, 5,4,9,
    
    5,2,9, 8,1,6, 4,7,3,
    4,3,1, 7,9,2, 8,5,6,
    6,8,7, 5,4,3, 1,9,2,
        
    2,0,3, 4,6,9, 7,1,8,
    7,1,8, 2,3,5, 9,6,4,
    9,6,4, 1,7,8, 2,3,5]
    
    game = Game.new(complex_game)
    game.solve()
    assert(game.is_solved?)
    assert_equal(@expected_solution, game.board)
  end
  
  def test_real_game
    real_game = [
    3,0,5, 0,8,0, 6,2,0,
    0,0,0, 0,0,0, 0,0,0,
    0,0,0, 3,2,1, 0,4,9,
    
    5,2,9, 8,0,0, 4,0,0,
    0,0,0, 0,0,0, 0,0,0,
    0,0,7, 0,0,3, 1,9,2,
    
    2,5,0, 4,6,9, 0,0,0,
    0,0,0, 0,0,0, 0,0,0,
    0,6,4, 0,7,0, 2,0,5
    ]
    game = Game.new(real_game)
    game.solve()
    assert(game.is_solved?)
    assert_equal(@expected_solution, game.board)
  end
  
  def test_real_hard_game
    real_hard_game = [
    1,0,0, 0,8,0, 0,0,0,
    0,3,0, 6,5,0, 0,0,2,
    0,0,8, 0,0,2, 9,0,0,
    
    0,8,0, 0,0,9, 1,6,0,
    0,0,0, 1,0,7, 0,0,0,
    0,7,1, 8,0,0, 0,5,0,
    
    0,0,5, 4,0,0, 2,0,0,
    9,0,0, 0,7,6, 0,8,0,
    0,0,0, 0,0,0, 0,0,3]
    
    sln = [
    1,2,6,9,8,4,7,3,5,
    7,3,9,6,5,1,8,4,2,
    4,5,8,7,3,2,9,1,6,
    2,8,3,5,4,9,1,6,7,
    5,9,4,1,6,7,3,2,8,
    6,7,1,8,2,3,4,5,9,
    3,6,5,4,9,8,2,7,1,
    9,1,2,3,7,6,5,8,4,
    8,4,7,2,1,5,6,9,3]
    
    game = Game.new(real_hard_game)
    game.solve()
    assert(game.is_solved?)
    assert_equal(sln, game.board)
  end
  
  def test_real_game2
    real_game = [
    0,3,0,0,9,0,0,0,0,
    5,0,6,0,0,1,0,0,9,
    2,0,0,0,8,0,0,6,0,
    0,4,3,0,0,7,0,0,0,
    6,2,0,9,0,8,0,7,5,
    0,0,0,1,0,0,3,2,0,
    0,7,0,0,1,0,0,0,4,
    9,0,0,7,0,0,1,0,2,
    0,0,0,0,6,0,0,9,0]
    
    sln = [
    4,3,7,6,9,2,5,8,1,
    5,8,6,3,7,1,2,4,9,
    2,1,9,4,8,5,7,6,3,
    8,4,3,5,2,7,9,1,6,
    6,2,1,9,3,8,4,7,5,
    7,9,5,1,4,6,3,2,8,
    3,7,2,8,1,9,6,5,4,
    9,6,8,7,5,4,1,3,2,
    1,5,4,2,6,3,8,9,7]
    
    game = Game.new(real_game)
    game.solve()
    assert(game.is_solved?)
    assert_equal(sln, game.board)
  end
end