acpc_poker_match_state 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6618d28c4865bcd57c7e77e4ee6b6d11fb5dad90
+  data.tar.gz: 35417f8b38e6a3ceeb9d0c33439a7f2188c73f47
+SHA512:
+  metadata.gz: 1ecdb73fb76a72af30fcdfd3bd4a4268244ba555f9b9f034a80cef88da3c552bd5fef4da43c9a36aba8f2f7404b06f1b994af93edd85dfa9adcae35f44741269
+  data.tar.gz: a759861ac7d87f384dcf1087baa2b15cf28bb49d245444aaf0e37d5dd9739f7f4a76a83b9deceff73fc632f7b7483e8217dd12e36763073a780991ba63ea2829

data/Rakefile

@@ -1,20 +1,16 @@
+#!/usr/bin/env rake
 require 'bundler/gem_tasks'
 require 'rake'
-require 'rspec/core/rake_task'
+require 'rake/testtask'
 
 require File.expand_path('../lib/acpc_poker_match_state/version', __FILE__)
 require File.expand_path('../tasks', __FILE__)
 
 include Tasks
 
-RSpec::Core::RakeTask.new(:spec) do |t|
-   ruby_opts = "-w"
-end
-
-task :build => :spec do
-   system "gem build acpc_poker_match_state.gemspec"
-end
-
-task :tag => :build do
-   tag_gem_version AcpcPokerMatchState::VERSION
+Rake::TestTask.new do |t|
+  t.libs << "lib" << 'spec/support'
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+  t.warning = true
 end

data/acpc_poker_match_state.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/dmorrill10/acpc_poker_match_state"
   s.summary     = %q{ACPC Poker Match State}
   s.description = %q{Match state data manager.}
-  
+
   s.add_dependency 'acpc_poker_types'
   s.add_dependency 'dmorrill10-utils'
 
@@ -19,10 +19,11 @@ Gem::Specification.new do |s|
   s.test_files    = Dir.glob "spec/**/*"
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'mocha'
-  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'turn'
+  s.add_development_dependency 'minitest'
   s.add_development_dependency 'acpc_dealer_data'
   s.add_development_dependency 'acpc_dealer'
   s.add_development_dependency 'awesome_print'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-rescue'
 end

data/lib/acpc_poker_match_state/players_at_the_table.rb

@@ -83,7 +83,7 @@ class PlayersAtTheTable
 
   def next_player_to_act(state=@transition.next_state)
     return nil unless state && !hand_ended? && !active_players.empty?
-      
+
     reference_position = if state.number_of_actions_this_round > 0
       position_relative_to_dealer player_who_acted_last
     else
@@ -386,6 +386,7 @@ class PlayersAtTheTable
     raise NoChipsToDistribute unless pot > 0
     raise NoPlayersToTakeChips unless non_folded_players.length > 0
 
+    # @todo This only works for Doyle's game where there are no side-pots.
     if 1 == non_folded_players.length
       non_folded_players.first.take_winnings! pot
     else
@@ -401,17 +402,13 @@ class PlayersAtTheTable
         hand_strength == strength_of_strongest_hand
       end.map { |player_with_hand_strength| player_with_hand_strength.first }
 
-      amount_each_player_wins = (pot/winning_players.length).floor
+      amount_each_player_wins = pot/winning_players.length.to_r
       winning_players.each do |player|
         player.take_winnings! amount_each_player_wins
       end
-
-      # @todo Keep track of chips remaining in the pot after splitting them if multiplayer
-      #@value -= (amount_each_player_wins * winning_players.length).to_i
     end
   end
 
-  # @todo This only works for Doyle's game where there are no side-pots.
   def pot
     chip_contributions.mapped_sum.sum
   end

data/lib/acpc_poker_match_state/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerMatchState
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/match_state_transition_spec.rb

@@ -1,7 +1,7 @@
 
-require File.expand_path('../support/spec_helper', __FILE__)
+require_relative 'support/spec_helper'
 
-require File.expand_path('../../lib/acpc_poker_match_state/match_state_transition', __FILE__)
+require_relative '../lib/acpc_poker_match_state/match_state_transition'
 
 describe MatchStateTransition do
 
@@ -11,92 +11,92 @@ describe MatchStateTransition do
 
   describe '#set_next_state!' do
     it 'assigns the new state to be the next state' do
-      new_state = mock 'MatchState'
+      new_state = 'new match state'
 
       @patient.set_next_state! new_state
-      @patient.next_state.should == new_state
+      @patient.next_state.must_equal new_state
     end
     it 'replaces the last state' do
-      last_state = mock 'MatchState'
+      last_state = 'last match state'
 
       @patient.set_next_state! last_state
-      @patient.last_state.should == nil
-      @patient.next_state.should == last_state
+      @patient.last_state.must_equal nil
+      @patient.next_state.must_equal last_state
 
-      next_state = mock 'MatchState'
+      next_state = 'new match state'
 
       @patient.set_next_state! next_state
-      @patient.last_state.should == last_state
-      @patient.next_state.should == next_state
-      @patient.last_state.should_not be next_state
+      @patient.last_state.must_equal last_state
+      @patient.next_state.must_equal next_state
+      @patient.last_state.wont_be_same_as next_state
     end
   end
   describe '#new_round?' do
     it 'raises an exception if it is called before #next_state!' do
-      expect do
+      -> do
         @patient.new_round?
-      end.to raise_exception(MatchStateTransition::NoStateGiven)
+      end.must_raise(MatchStateTransition::NoStateGiven)
     end
     describe 'reports true' do
       it 'when given an initial state' do
-        new_state = mock 'MatchState'
+        new_state = 'new match state'
 
-        @patient.set_next_state!(new_state).new_round?.should == true
+        @patient.set_next_state!(new_state).new_round?.must_equal true
       end
       it 'when subsequently given a state with a later round' do
-        initial_state = mock 'MatchState'
-        initial_state.stubs(:round).returns(0)
+        initial_state = MiniTest::Mock.new
+        initial_state.expect :round, 0
 
         @patient.set_next_state! initial_state
 
-        new_state = mock 'MatchState'
-        new_state.stubs(:round).returns(1)
+        new_state = MiniTest::Mock.new
+        new_state.expect :round, 1
 
-        @patient.set_next_state!(new_state).new_round?.should == true
+        @patient.set_next_state!(new_state).new_round?.must_equal true
       end
       it 'when subsequently given a state with an earlier round' do
-        initial_state = mock 'MatchState'
-        initial_state.stubs(:round).returns(1)
+        initial_state = MiniTest::Mock.new
+        initial_state.expect :round, 1
 
         @patient.set_next_state! initial_state
 
-        new_state = mock 'MatchState'
-        new_state.stubs(:round).returns(0)
+        new_state = MiniTest::Mock.new
+        new_state.expect :round, 0
 
-        @patient.set_next_state!(new_state).new_round?.should == true
+        @patient.set_next_state!(new_state).new_round?.must_equal true
       end
     end
     it 'reports false when subsequently given a state with the same round' do
-      initial_state = mock 'MatchState'
-      initial_state.stubs(:round).returns(0)
+      initial_state = MiniTest::Mock.new
+      initial_state.expect :round, 0
 
       @patient.set_next_state! initial_state
 
-      new_state = mock 'MatchState'
-      new_state.stubs(:round).returns(0)
+      new_state = MiniTest::Mock.new
+      new_state.expect :round, 0
 
-      @patient.set_next_state!(new_state).new_round?.should == false
+      @patient.set_next_state!(new_state).new_round?.must_equal false
     end
   end
   describe '#initial_state?' do
     it 'raises an exception if it is called before #next_state!' do
-      expect do
+      -> do
         @patient.initial_state?
-      end.to raise_exception(MatchStateTransition::NoStateGiven)
+      end.must_raise(MatchStateTransition::NoStateGiven)
     end
     it 'reports true when given a state that reports it is the first ' +
     'state of the first round' do
-      new_state = mock 'MatchState'
-      new_state.stubs(:first_state_of_first_round?).returns(true)
+      new_state = MiniTest::Mock.new
+      new_state.expect :first_state_of_first_round?, true
 
-      @patient.set_next_state!(new_state).initial_state?.should == true
+      @patient.set_next_state!(new_state).initial_state?.must_equal true
     end
     it 'reports false when given a state that reports it is not the ' +
     'first state of the first round' do
-      new_state = mock 'MatchState'
-      new_state.stubs(:first_state_of_first_round?).returns(false)
+      new_state = MiniTest::Mock.new
+      new_state.expect :first_state_of_first_round?, false
 
-      @patient.set_next_state!(new_state).initial_state?.should == false
+      @patient.set_next_state!(new_state).initial_state?.must_equal false
     end
   end
 end

data/spec/players_at_the_table_spec.rb

@@ -1,128 +1,43 @@
 
 require File.expand_path('../support/spec_helper', __FILE__)
 
-require 'acpc_poker_types/game_definition'
+require 'acpc_dealer'
+require 'acpc_dealer_data'
 
 require File.expand_path('../../lib/acpc_poker_match_state/players_at_the_table', __FILE__)
 
 describe PlayersAtTheTable do
-
-  INITIAL_STACK_SIZE = 2000
-  SMALL_BET = 100
-
-  describe '::seat_players' do
-    describe 'raises an exception if it is given' do
-      describe 'a user seat' do
-        it 'that is out of bounds' do
-          [-1, 2].each do |out_of_bounds_seat|
-            player_list = init_two_player_list
-            game_def = mock('GameDefinition')
-            game_def.stubs(:number_of_players).returns(player_list.length)
-            game_def.stubs(:chip_stacks).returns(player_list.map{|p| p.chip_stack})
-            game_def.stubs(:min_wagers).returns([0])
-
-            expect do
-              PlayersAtTheTable.seat_players(
-                game_def,
-                player_list.map{|p| p.name},
-                out_of_bounds_seat,
-                1
-              )
-            end.to raise_exception(PlayersAtTheTable::UsersSeatOutOfBounds)
-          end
-          player_list = init_two_player_list
-          # Increment each player's seat in order to make sure no player is in seat zero
-          player_list.map do |player|
-            old_seat = player.seat
-            player.stubs(:seat).returns(old_seat + 1)
-          end
-
-          Player.stubs(:create_players).returns(player_list)
-
-          expect do
-            PlayersAtTheTable.seat_players(
-              mock('GameDefinition'),
-              player_list.map{|p| p.name},
-              0,
-              1
-            )
-          end.to raise_exception(PlayersAtTheTable::UsersSeatOutOfBounds)
-        end
-      end
-    end
-    it 'works properly' do
-      various_numbers_of_players do |number_of_players|
-        player_list = init_vanilla_player_list(number_of_players)
-
-        player_list.length.times do |users_seat|
-          check_various_valid_creation_configurations(player_list,
-                                                      users_seat) { |example| }
-        end
-      end
-    end
-  end
   describe '#update!' do
-    describe 'keeps track of player positions and stacks' do
-      it 'after the initial state, before any actions' do
-        pending 'This unit test is too complex to be useful or maintain for now'
-
-        various_numbers_of_players do |number_of_players|
-          number_of_players.times do |users_seat|
-            player_list = init_vanilla_player_list(number_of_players)
-
-            check_various_valid_initial_update_configurations(player_list,
-                                                              users_seat) { |example| }
-          end
-        end
-      end
-      describe 'in two player' do
-        describe 'limit' do
-          it 'after a non-terminal sequence of four actions' do
-
-            pending 'This unit test is too complex to be useful or maintain for now'
-
-            check_non_terminal_four_action_sequence { |example| }
-          end
-          describe 'after a terminal sequence of five actions the sequence' do
-            it 'where the second player calls' do
-
-              pending 'This unit test is too complex to be useful or maintain for now'
-
-              check_non_terminal_four_action_sequence do |prev_example|
-
-                match_state = prev_example.given.match_state
-                players = prev_example.then.players
-                player_acting_sequence = prev_example.then.player_acting_sequence
-
-                player_who_acted_last = prev_example.then.next_player_to_act
-                index_of_player_who_acted_last = players.index(player_who_acted_last)
-
-                local_index_of_next_player_to_act = index_of_next_player_to_act(
-                  @initial_example.given.first_positions_relative_to_dealer[match_state.round],
-                  2, players.length
-                )
-                next_player_to_act = players[local_index_of_next_player_to_act]
-
-                player_acting_sequence.last << index_of_player_who_acted_last
-
-                setup_actions_taken_this_hand! players, index_of_player_who_acted_last,
-                  match_state.round, match_state.last_action
-
-                match_state.stubs(:list_of_hole_card_hands).returns(@hands)
-
-                # Cause a showdown
-
-                users_seat = match_state.position_relative_to_dealer
-                @hands.each_index do |i|
-                  @hands[i].stubs(:empty?).returns(false)
-
-                  players[i].expects(:assign_cards!).with(@hands[i]) unless i == users_seat
-                end
-
-                prev_example = create_and_check_update_example match_state,
-                  players, player_acting_sequence, next_player_to_act,
-                  player_who_acted_last
-              end
+    it "keeps track of state for a sequence of match states and actions in Doyle's game" do
+      # Change this number to do more or less thorough tests.
+      # Some interesting three player hands occur after 120
+      # Careful though, even 10 hands takes about five seconds,
+      # and it scales about linearly
+      num_hands = 10
+      match_logs.each do |log_description|
+        @match = PokerMatchData.parse_files(
+          log_description.actions_file_path,
+          log_description.results_file_path,
+          log_description.player_names,
+          AcpcDealer::DEALER_DIRECTORY,
+          num_hands
+        )
+        @match.for_every_seat! do |users_seat|
+
+          @patient = PlayersAtTheTable.seat_players(
+            @match.match_def.game_def,
+            (@match.players.map{ |player| player.name }),
+            users_seat,
+            num_hands
+          )
+
+          check_patient
+
+          @match.for_every_hand! do
+            @match.for_every_turn! do
+              @patient.update! @match.current_hand.current_match_state
+
+              check_patient
             end
           end
         end
@@ -130,493 +45,149 @@ describe PlayersAtTheTable do
     end
   end
 
-  def check_non_terminal_four_action_sequence
-    player_list = init_two_player_list
-
-    check_various_valid_initial_update_configurations(player_list) do |prev_example|
-
-      init_actions_taken_in_current_round player_list.length
-
-      prev_example = check_initial_call! prev_example
-
-      ###### Next turn, and next round
-      action = prev_example.given.match_state.last_action
-      player_acting_sequence = prev_example.then.player_acting_sequence
-
-      # Update the round
-      match_state = prev_example.given.match_state
-      last_round = match_state.round
-      match_state.stubs(:round).returns(1)
-      match_state.stubs(:in_new_round?).with(last_round).returns(true)
-
-      # Setup player who acted and will act next turn
-      players = prev_example.then.players
-
-      players.each do |player|
-        player.expects(:start_next_round!)
+  def check_patient(patient=@patient)
+    patient.player_acting_sequence.must_equal @match.player_acting_sequence
+    patient.number_of_players.must_equal @match.players.length
+    check_last_action
+    check_next_to_act
+    check_last_turn
+    patient.opponents_cards_visible?.must_equal @match.opponents_cards_visible?
+    patient.reached_showdown?.must_equal @match.opponents_cards_visible?
+    patient.less_than_two_non_folded_players?.must_equal @match.non_folded_players.length < 2
+
+    if @match.current_hand
+      patient.hand_ended?.must_equal @match.current_hand.final_turn?
+      patient.match_ended?.must_equal (@match.final_hand? && @match.current_hand.final_turn?)
+    end
+    patient.last_hand?.must_equal (
+      if @match.final_hand?.nil?
+        false
+      else
+        @match.final_hand?
       end
+    )
+    patient.player_acting_sequence_string.must_equal @match.player_acting_sequence_string
+    patient.users_turn_to_act?.must_equal @match.users_turn_to_act?
+    check_betting_sequence(patient)
+    # @todo Test this eventually
+    # patient.min_wager.to_i.must_equal @min_wager.to_i
+  end
 
-      player_who_acted_last = prev_example.then.next_player_to_act
-      index_of_player_who_acted_last = players.index(player_who_acted_last)
-
-      local_index_of_next_player_to_act = @initial_example.given.first_positions_relative_to_dealer[match_state.round]
-      next_player_to_act = players[local_index_of_next_player_to_act]
-
-      player_acting_sequence.last << index_of_player_who_acted_last
-      player_acting_sequence << []
-
-      # Since this is a new round
-      @actions_taken_this_hand.each_index do |i|
-        @actions_taken_this_hand[i] << []
+  def check_player_blind_relation(patient)
+    expected_player_blind_relation = @match.player_blind_relation
+    patient.player_blind_relation.each do |player, blind|
+      expected_player_and_blind = expected_player_blind_relation.to_a.find do |player_and_blind|
+        player_and_blind.first.seat == player.seat
       end
 
-      setup_actions_taken_this_hand! players, index_of_player_who_acted_last,
-        last_round, action
-
-      prev_example = create_and_check_update_example match_state, players, player_acting_sequence,
-        next_player_to_act, player_who_acted_last
-
-      ####### Next turn
-
-      match_state = prev_example.given.match_state
-      match_state.stubs(:last_action).returns(action)
-      match_state.stubs(:round).returns(1)
-      match_state.stubs(:in_new_round?).with(match_state.round).returns(false)
+      expected_player = expected_player_and_blind.first
+      expected_blind = expected_player_and_blind.last
 
-      # Setup player who acted and will act next turn
-      players = prev_example.then.players
-
-      player_who_acted_last = prev_example.then.next_player_to_act
-      index_of_player_who_acted_last = players.index(player_who_acted_last)
-
-      local_index_of_next_player_to_act = index_of_next_player_to_act(
-        @initial_example.given.first_positions_relative_to_dealer[match_state.round],
-        1, players.length
-      )
-      next_player_to_act = players[local_index_of_next_player_to_act]
-
-      player_acting_sequence.last << index_of_player_who_acted_last
-
-      setup_actions_taken_this_hand! players, index_of_player_who_acted_last,
-        match_state.round, action
-
-      # Check result. Actions taken so far should be: cc/r
-      prev_example = create_and_check_update_example match_state, players, player_acting_sequence,
-        next_player_to_act, player_who_acted_last
-
-      yield prev_example
+      player.close_enough?(expected_player).must_equal true
+      blind.must_equal expected_blind
     end
   end
-  def check_initial_call!(prev_example)
-    action = init_vanilla_action
-
-    # Setup match state
-    match_state = prev_example.given.match_state
-    match_state.stubs(:last_action).returns(action)
-    match_state.stubs(:in_new_round?).with(match_state.round).returns(false)
-    match_state.stubs(:number_of_actions_this_round).returns(1)
-    match_state.stubs(:number_of_actions_this_hand).returns(1)
-
-    # Ensure players are active and have cards
-    players = prev_example.then.players
-    players.each_index do |i|
-      player = players[i]
-
-      player.stubs(:active?).returns(true)
-      player.stubs(:folded?).returns(false)
-      player.stubs(:hole_cards).returns(@hands[i])
+  def check_betting_sequence(patient)
+    patient_betting_sequence = patient.betting_sequence.map do |actions|
+        actions.map { |action| action.to_low_res_acpc }
     end
+    expected_betting_sequence = @match.betting_sequence.map do |actions|
+      actions.map { |action| action.to_low_res_acpc }
+    end
+    patient_betting_sequence.must_equal expected_betting_sequence
 
-    # Setup player who acted and will act next turn
-    player_who_acted_last = prev_example.then.next_player_to_act
-    index_of_player_who_acted_last = players.index(player_who_acted_last)
-
-    player_acting_sequence = [[index_of_player_who_acted_last]]
-
-    setup_actions_taken_this_hand! players, index_of_player_who_acted_last,
-      match_state.round, action
-
-    next_player_to_act = players[index_of_next_player_to_act(
-                                   @initial_example.given.first_positions_relative_to_dealer[0], 1,
-                                   players.length
-    )]
-
-    # Check result. Actions taken so far should be: c
-    create_and_check_update_example match_state, players,
-      player_acting_sequence, next_player_to_act, player_who_acted_last
-  end
-  def check_various_valid_initial_update_configurations(player_list, users_seat=0)
-    check_various_valid_creation_configurations(player_list,
-    users_seat) do |prev_example|
-      match_state = initial_vanilla_match_state prev_example.then.players,
-        prev_example.given.users_seat
-
-      opponent_hand = init_vanilla_hand
-      @hands = [].fill opponent_hand, 0..(prev_example.then.number_of_players - 1)
-      Hand.stubs(:new).returns(opponent_hand)
-
-      @hands[@initial_example.given.users_seat] = match_state.users_hole_cards
-
-      prev_example.then.players.each_index do |i|
-        player = prev_example.then.players[i]
-
-        player.stubs(:active?).returns(true)
-
-        player.expects(:start_new_hand!).with(@initial_example.given.blinds[i],
-                                              INITIAL_STACK_SIZE,
-                                              @hands[i])
+    patient.betting_sequence_string.scan(/([a-z]\d*|\/)/).flatten.map do |action|
+      if action.match(/\//)
+        action
+      else
+        PokerAction.new(action).to_low_res_acpc
       end
-
-      example = update_example match_state, prev_example.then.players, [[]],
-        prev_example.then.players[prev_example.given.first_positions_relative_to_dealer[0]]
-
-      @patient.update! example.given.match_state
-
-      check_patient example.then
-
-      yield example
+    end.join('').must_equal @match.betting_sequence_string
+  end
+  def check_last_action(patient=@patient)
+    if @match.current_hand && @match.current_hand.last_action
+      patient.player_who_acted_last.seat.must_equal @match.current_hand.last_action.seat
+    else
+      patient.player_who_acted_last.must_be_nil
     end
   end
-  def check_various_valid_creation_configurations(player_list, users_seat=0)
-    number_of_players = player_list.length
-
-    example_first_positions = first_positions_relative_to_dealer(number_of_players)
-
-    @initial_example = creation_example player_list, users_seat,
-      example_first_positions
-
-    game_def = mock 'GameDefinition'
-    game_def.stubs(:first_positions_relative_to_dealer).returns(@initial_example.given.first_positions_relative_to_dealer)
-    game_def.stubs(:blinds).returns(@initial_example.given.blinds)
-    game_def.stubs(:min_wagers).returns([0])
-
-    Player.stubs(:create_players).returns(@initial_example.given.players)
-
-    @patient = PlayersAtTheTable.seat_players(
-      game_def,
-      @initial_example.given.players.map{|p| p.name},
-      @initial_example.given.users_seat,
-      1
-    )
-
-    check_patient @initial_example.then
-
-    yield @initial_example
+  def check_next_to_act(patient=@patient)
+    if @match.current_hand && @match.current_hand.next_action
+      patient.next_player_to_act.seat.must_equal @match.current_hand.next_action.seat
+    else
+      patient.next_player_to_act.must_be_nil
+    end
   end
-  def index_of_next_player_to_act(first_position_relative_to_dealer_in_current_round,
-                                  number_of_actions_in_current_round, number_of_players)
-    (first_position_relative_to_dealer_in_current_round + number_of_actions_in_current_round) % number_of_players
+  def check_last_turn(patient=@patient)
+    return unless @match.current_hand && @match.current_hand.final_turn?
+    patient.players.players_close_enough?(@match.players).must_equal true
+    patient.user_player.close_enough?(@match.player).must_equal true
+    patient.opponents.players_close_enough?(@match.opponents).must_equal true
+    patient.non_folded_players.players_close_enough?(@match.non_folded_players).must_equal true
+    patient.active_players.players_close_enough?(@match.active_players).must_equal true
+    patient.player_with_dealer_button.close_enough?(@match.player_with_dealer_button).must_equal true
+    check_player_blind_relation(patient)
+    patient.chip_stacks.must_equal @match.chip_stacks
+    patient.chip_balances.must_equal @match.chip_balances
+    patient.chip_contributions.sum.must_equal @match.chip_contributions.sum
   end
-  def create_and_check_update_example(match_state, players, player_acting_sequence, next_player_to_act,
-                                      player_who_acted_last)
-    example = update_example match_state, players, player_acting_sequence,
-      next_player_to_act, player_who_acted_last
-
-    # Initiate test
-    @patient.update! example.given.match_state
-
-    check_patient example.then
+end
 
-    example
+class Array
+  def players_close_enough?(other_players)
+    return false if other_players.length != length
+    each_with_index do |player, index|
+      return false unless player.close_enough?(other_players[index])
+    end
+    true
   end
-  def update_example(match_state, expected_players,
-                     expected_player_acting_sequence,
-                     next_player_to_act, player_who_acted_last=nil)
-    example = init_players_at_the_table_example(
-      "check update! when given matchstate #{match_state}",
-    [:match_state])
-
-    example.given.match_state = match_state
-
-    example.then.players = expected_players
-    example.then.round = match_state.round
-    example.then.player_acting_sequence = expected_player_acting_sequence
-    example.then.number_of_players = expected_players.length
-    example.then.player_who_acted_last = player_who_acted_last
-    example.then.next_player_to_act = next_player_to_act
-
-    example
+  def reject_empty_elements
+    reject do |elem|
+      elem.empty?
+    end
   end
-  def creation_example(player_list, users_seat, example_first_positions)
-    example = init_players_at_the_table_example(
-      "check creation for #{player_list.length}, where the user's " +
-      "seat is #{users_seat}, and the first positions relative to " +
-      "the dealer in each round are #{example_first_positions}",
-    [:players, :users_seat, :first_positions_relative_to_dealer, :blinds])
-
-    example.given.players = player_list
-    example.given.users_seat = users_seat
-    example.given.first_positions_relative_to_dealer = example_first_positions
-    example.given.blinds = reverse_blinds player_list.length
+end
 
-    example.then.players = player_list
-    example.then.round = nil
-    example.then.player_acting_sequence = [[]]
-    example.then.number_of_players = player_list.length
-    example.then.player_who_acted_last = nil
-    example.then.next_player_to_act = nil
+class PokerAction
+  # @return [Hash] Map of specific to general actions to more specific actions (e.g. check to call and bet to raise).
+  LOW_RESOLUTION_ACTION_CONVERSION = {call: :call, raise: :raise, fold: :fold, check: :call, bet: :raise}
 
-    example
+  def to_low_res_acpc
+    LEGAL_ACTIONS[LOW_RESOLUTION_ACTION_CONVERSION[@symbol]] + @modifier.to_s
+  end
+end
+class Player
+  def acpc_actions_taken_this_hand
+    acpc_actions = @actions_taken_this_hand.map do |actions_per_turn|
+      actions_per_turn.map { |action| action.to_low_res_acpc }
+    end
+    if acpc_actions.first.empty?
+      acpc_actions
+    else
+      acpc_actions.reject_empty_elements
+    end
   end
-  def init_players_at_the_table_example(description, given_parameters)
-    TestExample.new(
-      description, {given: given_parameters,
-                    then: [:players, :round, :player_acting_sequence,
-                           :number_of_players, :player_who_acted_last,
-                           :next_player_to_act]})
-                    end
-                    def initial_vanilla_match_state(player_list, users_seat=0)
-                      match_state = mock 'MatchState'
-
-                      match_state.stubs(:number_of_actions_this_round).returns(0)
-                      match_state.stubs(:number_of_actions_this_hand).returns(0)
-                      match_state.stubs(:first_state_of_first_round?).returns(true)
-                      match_state.stubs(:position_relative_to_dealer).returns(users_seat)
-                      match_state.stubs(:round).returns(0)
-
-                      player_list.each do |player|
-                        player.stubs(:equals?).returns(false)
-                        player.stubs(:equals?).with(player).returns(true)
-                      end
-
-                      users_hand = init_vanilla_hand
-                      users_hand.stubs(:empty?).returns(false)
-
-                      match_state.stubs(:users_hole_cards).returns(users_hand)
-
-                      match_state
-                    end
-                    def init_vanilla_hand
-                      hand = mock 'Hand'
-                      hand.stubs(:empty?).returns(true)
-
-                      hand
-                    end
-                    def init_vanilla_action
-                      action = mock 'PokerAction'
-                      action.stubs(:to_acpc_character)
-
-                      action
-                    end
-                    def various_numbers_of_players
-                      10.times do |i|
-                        yield i+2
-                      end
-                    end
-                    def init_vanilla_player_list(number_of_players)
-                      player_list = []
-                      number_of_players.times do |seat|
-                        player_list << init_vanilla_player(seat)
-                      end
-
-                      player_list
-                    end
-                    def init_two_player_list
-                      init_vanilla_player_list(2)
-                    end
-                    def init_vanilla_player(seat)
-                      player = mock('Player')
-                      player.stubs(:actions_taken_this_hand).returns([[]])
-                      player.stubs(:seat).returns(seat)
-                      player.stubs(:chip_stack).returns(INITIAL_STACK_SIZE)
-                      player.stubs(:active?).returns(true)
-                      player.stubs(:name).returns('player')
-
-                      player
-                    end
-                    def init_actions_taken_in_current_round(number_of_players)
-                      @actions_taken_this_hand = []
-                      number_of_players.times do |i|
-                        player_list = []
-                        @actions_taken_this_hand << [player_list]
-                      end
-                    end
-                    def blinds(number_of_players)
-                      hash = zero_blinds number_of_players
-                      hash[0] = SMALL_BET/2
-                      hash[1] = SMALL_BET
-
-                      hash
-                    end
-                    def reverse_blinds(number_of_players)
-                      hash = zero_blinds number_of_players
-                      hash[0] = SMALL_BET
-                      hash[1] = SMALL_BET/2
-
-                      hash
-                    end
-                    def zero_blinds(number_of_players)
-                      hash = {}
-                      number_of_players.times do |i|
-                        hash[i] = 0
-                      end
-
-                      hash
-                    end
-                    def first_positions_relative_to_dealer(number_of_rounds)
-                      [].fill 0, 0..(number_of_rounds - 1)
-                    end
-                    def setup_actions_taken_this_hand!(players, index_of_player_who_acted_last,
-                                                       round, action)
-                      actions_taken_this_hand_before_action_is_taken = []
-                      @actions_taken_this_hand.each_index do |i|
-                        actions_taken_this_hand_before_action_is_taken << []
-                        @actions_taken_this_hand[i].each do |current_action|
-                          actions_taken_this_hand_before_action_is_taken[i] << current_action.dup
-                        end
-
-                        players[i].stubs(:actions_taken_this_hand).returns(actions_taken_this_hand_before_action_is_taken[i])
-                      end
-
-                      @actions_taken_this_hand[index_of_player_who_acted_last][round] << action
-
-                      action_appended = states('action_appended').starts_as('no')
-                      players[index_of_player_who_acted_last].expects(:take_action!).with(action).then(action_appended.is('yes'))
-                      players.each_index do |i|
-                        players[i].stubs(:actions_taken_this_hand).returns(
-                          @actions_taken_this_hand[i]
-                        ).when(action_appended.is('yes'))
-                      end
-                    end
-                    def check_patient(then_values)
-                      @patient.players.should == then_values.players
-                      @patient.player_acting_sequence.should == then_values.player_acting_sequence
-                      @patient.number_of_players.should == then_values.number_of_players
-                      @patient.player_who_acted_last.should == then_values.player_who_acted_last
-                      @patient.next_player_to_act.should == then_values.next_player_to_act
-                    end
-
-                    # @todo Move to MatchState #######
-
-                    #describe '::seat_players' do
-                    #   it 'creates players with names and starting stack amounts as given' do
-                    #      various_numbers_of_players_names_and_stack_sizes do |player_names_to_stack_map|
-                    #         match_state_methods_and_return_values =
-                    #            {number_of_players: player_names_to_stack_map.keys.length}
-                    #
-                    #         init_match_state(match_state_methods_and_return_values) do |match_state|
-                    #            player_names_to_stack_map.keys.length.times do |seat|
-                    #               # Easy case: the user is always the dealer
-                    #               match_state.stubs(:position_relative_to_dealer).with(seat).returns(seat)
-                    #            end
-                    #            patient = PlayersAtTheTable.seat_players player_names_to_stack_map,
-                    #               match_state
-                    #
-                    #            player_names = patient.players.map { |player| player.name }
-                    #            player_stacks = patient.players.map { |player| player.chip_stack.to_i }
-                    #
-                    #            player_names.should be == player_names_to_stack_map.keys
-                    #            player_stacks.should be == player_names_to_stack_map.values
-                    #         end
-                    #      end
-                    #   end
-                    #   it 'assigns zero as a stack amount if none is given' do
-                    #      pending 'Updates to MatchState'
-                    #   end
-                    #   describe 'raises an exception if' do
-                    #      it 'was not given an incorrect number of player names' do
-                    #         incorrect_number_of_player_configurations do |player_names_to_stack_map, match_state|
-                    #            expect{PlayersAtTheTable.seat_players(player_names_to_stack_map, match_state)}.to
-                    #               raise_exception(PlayersAtTheTable::IncorrectNumberOfPlayerNamesGiven)
-                    #         end
-                    #      end
-                    #   end
-                    #end
-                    #
-                    #def incorrect_number_of_player_configurations
-                    #   too_many_player_names do |player_names_to_stack_map, match_state|
-                    #      yield player_names_to_stack_map, match_state
-                    #   end
-                    #   too_few_player_names do |player_names_to_stack_map, match_state|
-                    #      yield player_names_to_stack_map, match_state
-                    #   end
-                    #end
-                    #
-                    #def too_many_player_names
-                    #   various_numbers_of_players_names_and_stack_sizes do |player_names_to_stack_map|
-                    #      init_match_state({number_of_players: player_names_to_stack_map.keys.length+1}) do |match_state|
-                    #         yield player_names_to_stack_map, match_state
-                    #      end
-                    #   end
-                    #end
-                    #
-                    #def too_few_player_names
-                    #   various_numbers_of_players_names_and_stack_sizes do |player_names_to_stack_map|
-                    #      init_match_state({number_of_players: player_names_to_stack_map.keys.length-1}) do |match_state|
-                    #         yield player_names_to_stack_map, match_state
-                    #      end
-                    #   end
-                    #end
-                    #
-                    #def init_match_state(stubbed_methods_return_value_map={})
-                    #   match_state = mock('MatchState')
-                    #   stubbed_methods_return_value_map.each do |method_to_stub, return_value|
-                    #      match_state.stubs(method_to_stub).returns(return_value)
-                    #   end
-                    #   yield match_state
-                    #end
-                    #
-                    #def various_numbers_of_players_names_and_stack_sizes
-                    #   [{'only_player_0' => 0}, {'only_player_1' => 1},
-                    #      {'p1' => 100, 'p2' => 200},
-                    #      {'p1' => 10, 'p2' => 10, 'p3' => 100}].each do |player_names_to_stack_map|
-                    #      yield player_names_to_stack_map
-                    #   end
-                    #end
 
-                    #describe 'the list of first seats' do
-                    #   it 'is shorter than the round number' do
-                    #      lists_of_first_seats_shorter_than_round_number do |list_of_first_seats, match_state|
-                    #         expect{MatchState.parse(match_state, list_of_first_seats)}.to raise_exception(MatchState::UnknownFirstSeat)
-                    #      end
-                    #   end
-                    #   it 'contains a seat that is not occupied by a player' do
-                    #      first_seat_in_each_round_with_one_not_occupied do |first_seat_in_each_round, match_state|
-                    #         expect{MatchState.parse(match_state, first_seat_in_each_round)}.to raise_exception(MatchState::FirstSeatIsUnoccupied)
-                    #      end
-                    #   end
-                    #end
-                    #it 'reports the correct first player in each round' do
-                    #   reports_correct_first_player do |first_seat_in_each_round|
-                    #      match_state = MATCH_STATE_LABEL + ':1:1::' + arbitrary_hole_card_hand + '|'
-                    #      first_seat_in_each_round.length.times do |i|
-                    #         match_state += '/Ah'
-                    #         patient = test_match_state_success match_state
-                    #         patient.first_player_in_current_round.seat.should == first_seat_in_current_round[i]
-                    #      end
-                    #   end
-                    #end
+  def close_enough?(other)
+
+    unless (@name == other.name &&
+    @seat == other.seat &&
+    @chip_stack == other.chip_stack &&
+    @chip_balance == other.chip_balance &&
+    acpc_actions_taken_this_hand == other.acpc_actions_taken_this_hand)
+      puts "name: #{name == other.name}"
+      puts "seat: #{seat == other.seat}"
+      puts "chip_stack: #{chip_stack}, other: #{other.chip_stack}"
+      puts "chip balances: #{chip_balance}, other: #{other.chip_balance}"
+      puts "actions_taken_this_hand: #{acpc_actions_taken_this_hand}, other: #{other.acpc_actions_taken_this_hand}"
+      puts "all_in: #{all_in?}, other: #{other.all_in?}"
+    end
 
 
-                    # @todo From MatchState
-                    #:unknown_first_seat, :first_seat_is_unoccupied
-                    #@first_seat_in_each_round = validate_first_seats list_of_first_seats
-                    # @param [Array<Integer>] first_player_position_in_each_round The seat of the first player in each round.
-                    #
-                    #def lists_of_first_seats_shorter_than_round_number
-                    #   [[], [0], [0, 1]].each do |list_of_first_seats|
-                    #      match_state = MATCH_STATE_LABEL + ':0:0:'
-                    #      (list_of_first_seats.length).times do |i|
-                    #         match_state += 'c/'
-                    #      end
-                    #      match_state += ":#{arbitrary_hole_card_hand}|"
-                    #      yield list_of_first_seats, match_state
-                    #   end
-                    #end
-                    #
-                    #def first_seat_in_each_round_with_one_not_occupied
-                    #   [[-3], [2], [0, 1, 2], [0, 2, 1], [2, 1, 0]].each do |first_seat_in_each_round|
-                    #      match_state = MATCH_STATE_LABEL + ':0:0::'
-                    #      [first_seat_in_each_round.min.abs-2, first_seat_in_each_round.max-1].max.times do |i|
-                    #         match_state += arbitrary_hole_card_hand.to_s + '|'
-                    #      end
-                    #      yield first_seat_in_each_round, match_state
-                    #   end
-                    #end
-                    #
-                    #def reports_correct_first_player
-                    #   [[0], [0, 0], [0, 1], [0, 1, 0, 1]].each do |first_seat_in_current_round|
-                    #      yield first_seat_in_current_round
-                    #   end
-                    #end
-                    end
+    @name == other.name &&
+    @seat == other.seat &&
+    @chip_stack == other.chip_stack &&
+    @chip_balance == other.chip_balance &&
+    acpc_actions_taken_this_hand == other.acpc_actions_taken_this_hand
+  end
+end