neuro_gammon 0.7.0

data/test/test_base_player.rb

@@ -0,0 +1,32 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'neuro_gammon/base_player'
+
+class TestBasePlayer < Test::Unit::TestCase  
+  include NeuroGammon
+  
+  def test_init
+    b=BasePlayer.new
+    assert_not_nil b.id, "id should not be nil"
+    assert_not_nil b.name, "name should not be nil"
+    assert_equal "NeuroGammon::BasePlayer",b.name,"unexpected default name"
+  end
+  
+  def test_name
+    b=BasePlayer.new
+    b.name="bob"
+    assert_equal "bob",b.name,"name should be bob"
+  end
+  
+  def test_id
+    b=BasePlayer.new
+    b.id="bob"
+    assert_equal "bob",b.id,"id should be bob"
+  end
+end

data/test/test_board.rb

@@ -0,0 +1,384 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'neuro_gammon/board'
+require 'neuro_gammon/dice'
+
+
+class Array
+  def diff other_array
+    result=[]
+    self.each do |x|
+      result << x if (not other_array.include?(x))
+    end
+    
+    other_array.each do |x|
+      result << x if (not self.include?(x))
+    end
+    
+    return result.uniq
+  end
+  
+  def shuffle!
+    size.downto(1) { |n| push delete_at(rand(n)) }
+    self
+  end
+  
+end
+
+class TestBoard < Test::Unit::TestCase  
+  include NeuroGammon 
+  def setup
+    @board=Board.new
+    class << @board
+      def set=s
+        @board_state=s[0]
+        @bar=s[1]
+        raise Exception.new("Invalid state, wrong number of board positions:" << @board_state.size.to_s << ", should be 24") if @board_state.size!=24
+        raise Exception.new("Invalid state, wrong number of bar positions:" << @bar.size.to_s << ", should be 2") if @bar.size!=2
+      end
+    end    
+    
+    @dice=Dice.new
+    class << @dice
+      def set=values
+        @values=values
+        check_state
+      end
+    end
+  end
+  
+  def test_init    
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    assert_equal 15,@board.piece_count(Board::BLACK)
+    assert_equal 15,@board.piece_count(Board::WHITE)
+    assert_equal 0,@board.bar_count(Board::WHITE)
+    assert_equal 0,@board.bar_count(Board::BLACK)
+  end
+  
+  def test_colours
+    assert_equal(-1, Board::BLACK)
+    assert_equal(1,Board::WHITE)
+  end
+  
+  def test_move
+    
+    @board.move!([23,20],Board::WHITE)
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,1,0,0,1],[0,0]],@board.state
+    @board.move!([0,1],Board::BLACK)
+    assert_equal [[-1,-1,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,1,0,0,1],[0,0]],@board.state
+  end
+  
+  def test_invalid_moves    
+    
+    #test for moving to a row containing 5
+    assert_raise(Exception) {@board.move!([7,5],Board::WHITE)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+    #test start with no pieces
+    assert_raise(Exception) {@board.move!([22,21],Board::WHITE)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+    #test opposing colour at start
+    assert_raise(Exception) {@board.move!([11,10],Board::WHITE)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+    #test wrong direction (black)
+    assert_raise(Exception) {@board.move!([11,10],Board::BLACK)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+    #test wrong direction (white)
+    assert_raise(Exception) {@board.move!([12,13],Board::WHITE)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+    #test for destination wrong colour
+    assert_raise(Exception) {@board.move!([18,23],Board::BLACK)} 
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],@board.state
+    
+  end
+  
+  def test_bearing_off    
+    assert_equal false, @board.bearing_off?(Board::BLACK)
+    assert_equal false, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1],[0,0]]
+    assert_equal true, @board.bearing_off?(Board::BLACK)
+    assert_equal true, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,-1],[0,0]]
+    assert_equal false, @board.bearing_off?(Board::BLACK)
+    assert_equal false, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1],[0,0]]
+    assert_equal false, @board.bearing_off?(Board::BLACK)
+    assert_equal true, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1],[0,0]]
+    assert_equal true, @board.bearing_off?(Board::BLACK)
+    assert_equal false, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1],[1,0]]
+    assert_equal false, @board.bearing_off?(Board::BLACK)
+    assert_equal true, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1],[0,1]]
+    assert_equal true, @board.bearing_off?(Board::BLACK)
+    assert_equal false, @board.bearing_off?(Board::WHITE)
+    
+    @board.set=[[-5,5,5,4,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,-2,-1,-1,-4],[0,0]]
+    assert_equal true, @board.bearing_off?(Board::WHITE)
+  end
+  
+  def test_bar_count
+    
+    @board.set=[[0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0],[2,3]]
+    
+    assert_equal 2,@board.bar_count(Board::BLACK)
+    assert_equal 3,@board.bar_count(Board::WHITE)
+  end
+  
+  def test_piece_count
+    
+    assert_equal 15,@board.piece_count(Board::BLACK)
+    assert_equal 15,@board.piece_count(Board::WHITE)
+    
+    @board.set=@board.set=[[0,0,0,0,-3,5,5,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0],[2,3]]
+    assert_equal 6,@board.piece_count(Board::BLACK)
+    assert_equal 14,@board.piece_count(Board::WHITE)
+  end
+  
+  def test_move_bear_off
+    
+    @board.set=[[-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]]
+    @board.move!([5,-1],Board::WHITE)
+    assert_equal([[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]],@board.state)
+    
+    @board.set=[[1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]]
+    @board.move!([23,-1],Board::BLACK)
+    assert_equal([[1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0],[0,0]],@board.state)
+    
+    @board.move!([22,-1],Board::BLACK)
+    assert_equal([[1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]],@board.state)
+    
+    @board.set=[[-5,5,5,4,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,-2,-1,-1,-4],[0,0]]
+    @board.move!([4,-1],Board::WHITE)
+    assert_equal([[-5,5,5,4,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,-2,-1,-1,-4],[0,0]],@board.state)
+    
+  end
+  
+  def test_move_off_bar
+    
+    @board.set=[[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]]
+    
+    @board.move!([-1,1],Board::BLACK)
+    assert_equal([[-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[0,1]],@board.state)
+    
+    @board.set=[[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]]
+    @board.move!([-1,21],Board::WHITE)
+    assert_equal([[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1],[1,0]],@board.state)
+    
+    @board.set=[[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[2,1]]
+    @board.move!([-1,2],Board::BLACK)
+    assert_equal([[-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]],@board.state)
+    
+    @board.set=[[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,3]]
+    @board.move!([-1,20],Board::WHITE)
+    assert_equal([[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1],[1,2]],@board.state)
+  end
+  
+  def test_invalid_moves_bearing_off
+    
+    @board.set=[[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[0,0]] 
+    assert_raises(Exception) {@board.move!([22,-1],Board::BLACK)}
+    assert_equal [[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[0,0]],@board.state
+    
+    @board.set=[[1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[1,0]] 
+    assert_raises(Exception) {@board.move!([1,-1],Board::WHITE)}
+    assert_raises(Exception) {@board.move!([5,-1],Board::WHITE)}
+    assert_equal [[1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[1,0]],@board.state
+    
+  end
+  
+  def test_invalid_moves_bar
+    
+    @board.set=[[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]]
+    
+    #test trying to move a piece
+    assert_raises(Exception) {@board.move!([23,20],Board::WHITE)}
+    assert_equal [[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]],@board.state
+    
+    #test landing on oposing peice square
+    assert_raises(Exception) {@board.move!([-1,4],Board::BLACK)}
+    assert_equal [[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]],@board.state
+    
+    #test out of range
+    assert_raises(Exception) {@board.move!([-1,17],Board::WHITE)}
+    assert_equal [[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]],@board.state
+    
+    #test wrong end
+    assert_raises(Exception) {@board.move!([-1,2],Board::WHITE)}
+    assert_equal [[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]],@board.state
+    
+  end
+  
+  def test_move_knockoff
+    
+    @board.set=[[-1,-1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[0,0]]
+    @board.move!([0,4],Board::BLACK)
+    assert_equal([[0,-1,0,0,-1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[0,1]],@board.state)
+    
+    @board.set=[[-1,-1,0,0,1,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[0,0]]
+    @board.move!([7,5],Board::WHITE)
+    assert_equal([[-1,-1,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[1,0]],@board.state)
+    
+    @board.set=[[-1,-1,0,0,1,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[1,0]]
+    @board.move!([7,5],Board::WHITE)
+    assert_equal([[-1,-1,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,1],[2,0]],@board.state)
+    
+    @board.set=[[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]]
+    @board.move!([-1,22],Board::WHITE)
+    assert_equal([[-1,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],[2,0]],@board.state)
+    
+    @board.set=[[-1,1,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[1,1]]
+    @board.move!([-1,1],Board::BLACK)
+    assert_equal([[-1,-1,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1],[0,2]],@board.state)
+  end
+  
+  #Array.diff added method, added for tests
+  def test_array_diff
+    a=[1,2,3]
+    assert_equal [1],a.diff([2,3])
+    assert_equal [1],[2,3].diff(a)
+    assert_equal [1,2,3,4],a.diff([4])
+    assert_equal [4,1,2,3],[4].diff(a)
+    assert_equal [[1,2][3,4]], [[1,2][3,4],[5,6]].diff([[5,6]])
+    
+    assert_equal [1,2],[1,1,2,2,3,3,2,1].diff([3])
+    
+    assert_equal [[23,17],[23,25],[23,26]],[[23,17]].diff([[23,25],[23,26]])
+    
+  end
+  
+  def test_legal_moves
+    #very simple to start
+    
+    @board.set=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,0]]    
+    
+    @dice.set=[6,6]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[23,17]])
+    
+    @board.set=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,0]]    
+    @dice.set=[6,5]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[23,17],[23,18]])
+    
+    @board.set=[[0,0,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,0]]    
+    @dice.set=[1,2]
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[5,6],[5,7]])
+    
+    @board.set=[[0,0,0,0,0,-2,-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,0]]    
+    @dice.set=[1,2]
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[5,7],[6,7],[6,8]])
+    
+    #now for a piece on the bar
+    @board.set=[[0,0,0,0,0,-2,-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[1,0]]    
+    @dice.set=[1,2]
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[-1,0],[-1,1]])
+    
+    @board.set=[[0,0,0,0,0,-2,-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[1,2]]    
+    @dice.set=[1,5]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[-1,23],[-1,19]])
+    
+    #test moving out of range
+    @board.set=[[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1],[0,0]]    
+    @dice.set=[1,5]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[0,-1]])
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[23,-1]])
+    
+    @board.set=[[1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1],[0,0]]    
+    @dice.set=[1,5]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[21,16],[21,20]])
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[3,4],[3,8]])
+  end
+  
+  def test_valid_moves_bearing_off
+    
+    @board.set=[[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]]
+    assert_equal true,@board.bearing_off?(Board::WHITE)
+    assert_equal true,@board.bearing_off?(Board::BLACK)    
+    @dice.set=[1,2]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[0,-1]])
+    
+    @dice.set=[3,2]
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[22,-1]])
+    
+    #test can't bear off with higher slot taken
+    @board.set=[[1,1,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]]
+    @dice.set=[3,3]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[4,1]])
+    
+    #test bear off with dice higher than highest slot
+    @dice.set=[6,6]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[4,-1]])
+    
+    @board.set=[[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1],[0,0]]
+    @dice.set=[6,6]
+    valid=@board.valid_moves(Board::WHITE, @dice)
+    assert_equal [],valid.diff([[1,-1]])
+    valid=@board.valid_moves(Board::BLACK, @dice)
+    assert_equal [],valid.diff([[22,-1]])
+  end
+  
+  def test_random_sample_moves
+    r=rand(1000)
+    srand r
+    
+    @board.state.shuffle!    
+    c=rand(10)>5 ? Board::WHITE : Board::BLACK
+    valid=@board.valid_moves c,@dice
+    valid.each do |move|
+      begin
+        @board.validate_move(move,c)
+      rescue Exception => e
+        add_failure("Invalid move found. rand seed=" << r.to_s << ", error was " << e.message)
+      end
+    end
+  end
+    
+  
+  def test_winner
+    
+    assert_nil @board.winner
+    @board.set=[[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]]
+    assert_equal Board::BLACK,@board.winner
+    @board.set=[[-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]]
+    assert_equal Board::WHITE,@board.winner
+  end
+  
+  def test_move
+    
+    b2=Board.new
+    assert_equal([[-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 1, 1],
+                 [0, 0]],@board.move([23,22],Board::WHITE))
+    assert_equal b2.state,@board.state
+  end
+    
+end

data/test/test_board_tools.rb

@@ -0,0 +1,91 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'neuro_gammon/board_tools'
+require 'neuro_gammon/board' #FIXME: cyclic dependency on board, caused by Board::<colour> - this constant needs moving.
+
+class TestBoardTools < Test::Unit::TestCase
+  include NeuroGammon
+  include NeuroGammon::BoardTools
+  
+  def test_reverse_state
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1],[1,0]]
+    new_state=reverse_state state
+    assert_equal [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,1]],new_state
+    assert_equal [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1],[1,0]],state 
+    new_state = reverse_state [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-4,5],[3,2]]
+    assert_equal [[-5,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[2,3]],new_state
+    new_state = reverse_state [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]]
+    assert_equal [[-2,0,0,0,0,5,0,3,0,0,0,-5,5,0,0,0,-3,0,-5,0,0,0,0,2],[0,0]],new_state
+  end
+  
+  def test_test_for_gammon
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1],[0,0]] 
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]] 
+    assert_equal true,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal true,test_for_gammon(state,Board::BLACK)
+    
+    state=[[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+     state=[[0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1],[0,0]] 
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[-2,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]] 
+    assert_equal true,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,5],[0,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal true,test_for_gammon(state,Board::BLACK)
+    
+    state=[[4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4],[0,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,1]]
+    assert_equal true,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[0,1]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[1,0]] 
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[1,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal true,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,1]]
+    assert_equal true,test_for_gammon(state,Board::WHITE)
+    assert_equal false,test_for_gammon(state,Board::BLACK)
+    
+    state=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[1,0]]
+    assert_equal false,test_for_gammon(state,Board::WHITE)
+    assert_equal true,test_for_gammon(state,Board::BLACK)
+ 
+    
+    
+  end
+end