acpc_poker_types 0.0.10 → 1.0.0

data/spec/hand_results_spec.rb

@@ -0,0 +1,292 @@
+
+# Spec helper (must include first to track code coverage with SimpleCov)
+require_relative 'support/spec_helper'
+
+require 'mocha/setup'
+
+require 'acpc_dealer'
+
+require 'acpc_poker_types/acpc_dealer_data/hand_results'
+require 'acpc_poker_types/acpc_dealer_data/match_definition'
+
+describe AcpcPokerTypes::AcpcDealerData::HandResults do
+  before do
+    @patient = nil
+    @data = nil
+    @final_score = nil
+    @player_names = nil
+    @match_def = nil
+    @no_final_score = false
+  end
+
+  describe '::parse_state' do
+    it 'properly parses a ACPC log "STATE. . ." line' do
+      [
+        "STATE:0:rc/rrrrc/rc/crrrc:5d5c|9hQd/8dAs8s/4h/6d:28|-28:p1|p2\n" =>
+          {p1: 28, p2: -28},
+        "STATE:9:cc/cc/r165c/cc:4cKh|Kd7d/Ah9h9c/6s/Ks:0|0:p1|p2\n" =>
+          {p1: 0, p2: 0},
+        "STATE:18:rfrrc/cc/rrc/rrrrc:5d5c|9hQd|8dAs/8s4h6d/5s/Js:-5|-160|165:p1|p2|p3\n" =>
+          {p1: -5, p2: -160, p3: 165},
+        "STATE:1:cr13057cr20000cc///:Ks6h|Qs5d|Tc4d/Ah3dTd/8c/Qd:-20000|40000|-20000:p2|p3|p1\n" =>
+          {p1: -20000, p2: -20000, p3: 40000}
+      ].each do |state_to_player_results|
+        state_to_player_results.each do |state_string, expected_values|
+          AcpcPokerTypes::AcpcDealerData::HandResults.parse_state(state_string).must_equal expected_values
+        end
+      end
+    end
+    it 'returns nil if asked to parse an improperly formatted string' do
+      AcpcPokerTypes::AcpcDealerData::HandResults.parse_state("improperly formatted string").must_be_nil
+    end
+  end
+  describe '::parse_score' do
+    it 'properly parses a ACPC log "SCORE. . ." line' do
+      [
+        "SCORE:100|-100:p1|p2\n" => {p1: 100, p2: -100},
+        'SCORE:19835|621.5|-20455.5:p1|p2|p3' => {p1: 19835, p2: 621.5, p3: -20455.5}
+      ].each do |score_to_player_results|
+        score_to_player_results.each do |score_string, expected_values|
+          AcpcPokerTypes::AcpcDealerData::HandResults.parse_score(score_string).must_equal expected_values
+        end
+      end
+    end
+    it 'returns nil if asked to parse an improperly formatted string' do
+      AcpcPokerTypes::AcpcDealerData::HandResults.parse_score("improperly formatted string").must_be_nil
+    end
+  end
+
+  describe 'properly parses ACPC log statements' do
+    describe 'from file' do
+      it 'when every hand is desired' do
+        init_data do |log_statements|
+          file_name = 'file_name'
+          AcpcPokerTypes::AcpcDealerData::LogFile.stubs(:open).with(file_name, 'r').yields(
+            log_statements
+          ).returns(
+            AcpcPokerTypes::AcpcDealerData::HandResults.parse(
+              log_statements,
+              @player_names,
+              AcpcDealer::DEALER_DIRECTORY
+            )
+          )
+
+          @patient = AcpcPokerTypes::AcpcDealerData::HandResults.parse_file(
+            file_name,
+            @player_names,
+            AcpcDealer::DEALER_DIRECTORY
+          )
+
+          check_patient
+        end
+      end
+      it 'when a particular number of hands is desired' do
+        @no_final_score = true
+        num_hands = 3
+        init_data do |log_statements|
+          file_name = 'file_name'
+          AcpcPokerTypes::AcpcDealerData::LogFile.stubs(:open).with(file_name, 'r').yields(
+            log_statements
+          ).returns(
+            AcpcPokerTypes::AcpcDealerData::HandResults.parse(
+              log_statements,
+              @player_names,
+              AcpcDealer::DEALER_DIRECTORY,
+              num_hands
+            )
+          )
+
+          @patient = AcpcPokerTypes::AcpcDealerData::HandResults.parse_file(
+            file_name,
+            @player_names,
+            AcpcDealer::DEALER_DIRECTORY,
+            num_hands
+          )
+
+          # Fix data to check patient against
+          @final_score = nil
+          @data = @data[0..num_hands-1]
+
+          check_patient
+        end
+      end
+    end
+    describe 'from array' do
+      it 'when every hand is desired' do
+        init_data do |log_statements|
+          @patient = AcpcPokerTypes::AcpcDealerData::HandResults.parse(
+            log_statements,
+            @player_names,
+            AcpcDealer::DEALER_DIRECTORY
+          )
+
+          check_patient
+        end
+      end
+      it 'when a particular number of hands is desired' do
+        @no_final_score = true
+        num_hands = 3
+        init_data do |log_statements|
+          @patient = AcpcPokerTypes::AcpcDealerData::HandResults.parse(
+            log_statements,
+            @player_names,
+            AcpcDealer::DEALER_DIRECTORY,
+            num_hands
+          )
+
+          # Fix data to check patient against
+          @final_score = nil
+          @data = @data[0..num_hands-1]
+
+          check_patient
+        end
+      end
+    end
+  end
+
+  def check_patient
+    @patient.data.must_equal @data
+    @patient.final_score.must_equal @final_score unless @no_final_score
+    @patient.match_def.must_equal @match_def
+  end
+
+  def init_data
+    all_data.each do |game, data_hash|
+      @final_score = data_hash[:final_score]
+      @data = data_hash[:data]
+      @player_names = data_hash[:player_names]
+      @match_def = AcpcPokerTypes::AcpcDealerData::MatchDefinition.parse(
+        data_hash[:log_statements].first,
+        @player_names,
+        AcpcDealer::DEALER_DIRECTORY
+      )
+
+      yield data_hash[:log_statements]
+    end
+  end
+
+  def all_data
+    {
+      two_player_limit: {
+        log_statements: [
+          "# name/game/hands/seed 2p.limit.h1000.r0 holdem.limit.2p.reverse_blinds.game 1000 0\n",
+          "STATE:0:crrrc/rrc/rf:3s5d|Td2s/4d5c4s/Kd:60|-60:p1|p2\n",
+          "STATE:1:rc/crrrrc/rrc/rc:7d5s|Kh9c/As3hTs/Jh/Js:-120|120:p2|p1\n",
+          "STATE:2:cc/cc/rc/rc:Kh6h|As2h/Qd2c2d/7d/3d:-50|50:p1|p2\n",
+          "STATE:3:cc/rrrc/rc/rc:8c7d|QcKc/Ac6hTd/9h/3d:80|-80:p2|p1\n",
+          "STATE:4:rf:6s9d|4dQd:-10|10:p1|p2\n",
+          "STATE:5:cc/crc/cc/cc:6c2d|9cKs/4dKc7d/Td/Ah:-20|20:p2|p1\n",
+          "STATE:6:rrrc/rc/cc/rc:9h7h|3d8s/JcAc5c/Ah/Ks:70|-70:p1|p2\n",
+          "STATE:7:rrrf:5s9c|8dJh:-30|30:p2|p1\n",
+          "STATE:8:rrrc/cc/rc/rrc:Kc6h|Qc3s/QhAh8d/Th/9d:-100|100:p1|p2\n",
+          "STATE:9:crc/cc/cc/rc:Jc8d|TdQd/As6d6h/7h/4s:-40|40:p2|p1\n",
+          'SCORE:100|-100:p1|p2'
+        ],
+        data: [
+          {p1: 60, p2: -60},
+          {p1: 120, p2: -120},
+          {p1: -50, p2: 50},
+          {p1: -80, p2: 80},
+          {p1: -10, p2: 10},
+          {p1: 20, p2: -20},
+          {p1: 70, p2: -70},
+          {p1: 30, p2: -30},
+          {p1: -100, p2: 100},
+          {p1: 40, p2: -40}
+        ],
+        final_score: {p1: 100, p2: -100},
+        player_names: ['p1', 'p2']
+      },
+      two_player_nolimit: {
+        log_statements: [
+          "# name/game/hands/seed 2p.nolimit.h1000.r0 holdem.nolimit.2p.reverse_blinds.game 1000 0\n",
+          "STATE:0:r5924c/r17356c/cc/r19718c:3s5d|Td2s/4d5c4s/Kd/2c:19718|-19718:p1|p2\n",
+          "STATE:1:cc/r7485r16652c/r17998r19429r20000c/:7d5s|Kh9c/As3hTs/Jh/Js:-20000|20000:p2|p1\n",
+          "STATE:2:r18810c/r19264r19774c/cr19995r20000c/:Kh6h|As2h/Qd2c2d/7d/3d:-20000|20000:p1|p2\n",
+          "STATE:3:cr281c/r18446r20000c//:8c7d|QcKc/Ac6hTd/9h/3d:20000|-20000:p2|p1\n",
+          "STATE:4:r13583r20000f:6s9d|4dQd:13583|-13583:p1|p2\n",
+          "STATE:5:cc/r15416f:6c2d|9cKs/4dKc7d:100|-100:p2|p1\n",
+          "STATE:6:r15542r20000c///:9h7h|3d8s/JcAc5c/Ah/Ks:20000|-20000:p1|p2\n",
+          "STATE:7:r1147c/cc/cr5404f:5s9c|8dJh/TdQc9d/Jd:-1147|1147:p2|p1\n",
+          "STATE:8:cc/r5841r19996r20000c//:Kc6h|Qc3s/QhAh8d/Th/9d:-20000|20000:p1|p2\n",
+          "STATE:9:f:Jc8d|TdQd:50|-50:p2|p1\n",
+          'SCORE:14298|-14298:p1|p2'
+        ],
+        data: [
+          {p1: 19718, p2: -19718},
+          {p1: 20000, p2: -20000},
+          {p1: -20000, p2: 20000},
+          {p1: -20000, p2: 20000},
+          {p1: 13583, p2: -13583},
+          {p1: -100, p2: 100},
+          {p1: 20000, p2: -20000},
+          {p1: 1147, p2: -1147},
+          {p1: -20000, p2: 20000},
+          {p1: -50, p2: 50}
+        ],
+        final_score: {p1: 14298, p2: -14298},
+        player_names: ['p1', 'p2']
+      },
+      three_player_limit: {
+        log_statements: [
+          "# name/game/hands/seed 3p.limit.h1000.r0 holdem.limit.3p.game 1000 0\n",
+          "STATE:0:ccc/rrcrcrcc/rcrrcc/crcrcrcrfc:Kd2d|6c2s|8hTh/2c4h9s/Ad/As:360|-190|-170:p1|p2|p3\n",
+          "STATE:1:rrcrcc/rrrcf/rrrrc/cc:Td7s|4c5s|Qc4s/5dAd7c/6c/2c:210|-60|-150:p2|p3|p1\n",
+          "STATE:2:fcc/crc/crrc/rrc:Jh9d|8hAh|As6c/3dKc3c/2d/Kh:-100|100|0:p3|p1|p2\n",
+          "STATE:3:rcrcrcf/rc/cc/rc:Qd2h|5c4d|6s2d/As8s6d/7d/2c:-70|100|-30:p1|p2|p3\n",
+          "STATE:4:rrcc/rrrrcf/rrc/rc:8d4c|6sQd|Ts2s/2d9hTh/8c/5h:190|-130|-60:p2|p3|p1\n",
+          "STATE:5:rrrcc/crrfrrc/crc/cc:7cKh|3s2h|Js4h/KcQc2s/5h/4s:-40|-100|140:p3|p1|p2\n",
+          "STATE:6:rrcrcc/rrrcc/ccrrcrcrcc/crrrrfc:QhQd|3cQc|2cTh/Jc8hTs/9c/3s:95|95|-190:p1|p2|p3\n",
+          "STATE:7:crrcrcc/crrfrc/cc/rrc:Qd2s|KdTs|6dQh/6h6sTc/3h/Jd:-40|-110|150:p2|p3|p1\n",
+          "STATE:8:frc/cc/rc/rrc:6hKc|6cAd|6d2c/QdTd9h/7h/Jc:80|-80|0:p3|p1|p2\n",
+          "STATE:9:ccc/ccc/rrcc/rrrfrc:QsAs|3s8h|Qd3c/4d6d2d/5d/2c:-70|-130|200:p1|p2|p3\n",
+          'SCORE:105|375|-550:p1|p2|p3'
+        ],
+        data: [
+          {p1: 360, p2: -190, p3: -170},
+          {p1: -150, p2: 210, p3: -60},
+          {p1: 100, p2: 0, p3: -100},
+          {p1: -70, p2: 100, p3: -30},
+          {p1: -60, p2: 190, p3: -130},
+          {p1: -100, p2: 140, p3: -40},
+          {p1: 95, p2: 95, p3: -190},
+          {p1: 150, p2: -40, p3: -110},
+          {p1: -80, p2: 0, p3: 80},
+          {p1: -70, p2: -130, p3: 200}
+        ],
+        final_score: {p1: 105, p2: 375, p3: -550},
+        player_names: ['p1', 'p2', 'p3']
+      },
+      three_player_nolimit: {
+        log_statements: [
+          "# name/game/hands/seed 3p.nolimit.h1000.r0 holdem.nolimit.3p.game 1000 0\n",
+          "STATE:0:ccc/ccc/r4881cr14955cr20000cc/:Kd2d|6c2s|8hTh/2c4h9s/Ad/As:40000|-20000|-20000:p1|p2|p3\n",
+          "STATE:1:ccc/cr7400r17645r20000cc//:Td7s|4c5s|Qc4s/5dAd7c/6c/2c:40000|-20000|-20000:p2|p3|p1\n",
+          "STATE:2:r7187r19832cc/cr19953fc/cr20000c/:Jh9d|8hAh|As6c/3dKc3c/2d/Kh:-20000|39832|-19832:p3|p1|p2\n",
+          "STATE:3:r3610cr8213r19531r20000cc///:Qd2h|5c4d|6s2d/As8s6d/7d/2c:-20000|40000|-20000:p1|p2|p3\n",
+          "STATE:4:fcc/r1348c/r8244r18929r20000c/:8d4c|6sQd|Ts2s/2d9hTh/8c/5h:20000|-20000|0:p2|p3|p1\n",
+          "STATE:5:r15492cc/ccr17275cc/r19597cc/r19947cf:7cKh|3s2h|Js4h/KcQc2s/5h/4s:39544|-19947|-19597:p3|p1|p2\n",
+          "STATE:6:r10322fc/r10577r18645r20000c//:QhQd|3cQc|2cTh/Jc8hTs/9c/3s:-50|20050|-20000:p1|p2|p3\n",
+          "STATE:7:ccr8533r17298r20000cc///:Qd2s|KdTs|6dQh/6h6sTc/3h/Jd:-20000|-20000|40000:p2|p3|p1\n",
+          "STATE:8:cr18231r20000cc///:6hKc|6cAd|6d2c/QdTd9h/7h/Jc:40000|-20000|-20000:p3|p1|p2\n",
+          "STATE:9:ccr12926r20000cc///:QsAs|3s8h|Qd3c/4d6d2d/5d/2c:-20000|-20000|40000:p1|p2|p3\n",
+          'SCORE:19835|621|-20456:p1|p2|p3'
+        ],
+        data: [
+          {p1: 40000, p2: -20000, p3: -20000},
+          {p1: -20000, p2: 40000, p3: -20000},
+          {p1: 39832, p2: -19832, p3: -20000},
+          {p1: -20000, p2: 40000, p3: -20000},
+          {p1: 0, p2: 20000, p3: -20000},
+          {p1: -19947, p2: -19597, p3: 39544},
+          {p1: -50, p2: 20050, p3: -20000},
+          {p1: 40000, p2: -20000, p3: -20000},
+          {p1: -20000, p2: -20000, p3: 40000},
+          {p1: -20000, p2: -20000, p3: 40000}
+        ],
+        final_score: {p1: 19835, p2: 621, p3: -20456},
+        player_names: ['p1', 'p2', 'p3']
+      }
+    }
+  end
+end

data/spec/hand_spec.rb

@@ -3,13 +3,13 @@
 require File.expand_path('../support/spec_helper', __FILE__)
 
 
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/hand", __FILE__)
+require 'acpc_poker_types/hand'
 
-describe Hand do
+describe AcpcPokerTypes::Hand do
   describe '#initialize' do
     it 'understands every possible card combination' do
       for_every_two_cards! do |card_1, card_2|
-        @patient = Hand.new [card_1, card_2]
+        @patient = AcpcPokerTypes::Hand.new [card_1, card_2]
 
         check_patient
       end
@@ -18,7 +18,7 @@ describe Hand do
   describe '#from_acpc' do
     it 'understands every possible ACPC string hand' do
       for_every_two_cards! do |card_1, card_2|
-        @patient = Hand.from_acpc @acpc
+        @patient = AcpcPokerTypes::Hand.from_acpc @acpc
 
         check_patient
       end
@@ -27,7 +27,7 @@ describe Hand do
   describe '#draw_cards' do
     it 'understands every possible card combination' do
       for_every_two_cards! do |card_1, card_2|
-        @patient = Hand.draw_cards card_1, card_2
+        @patient = AcpcPokerTypes::Hand.draw_cards card_1, card_2
 
         check_patient
       end
@@ -35,18 +35,18 @@ describe Hand do
   end
 
   def check_patient
-    @patient.to_s.should be == @string
-    @patient.to_acpc.should be == @acpc
+    @patient.to_s.must_equal @string
+    @patient.to_acpc.must_equal @acpc
   end
   def for_every_card
-    Rank::DOMAIN.map do |rank, rank_properties|
-      Suit::DOMAIN.map do |suit, suit_properties|
-        yield Card.from_components(rank, suit)
+    AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
+      AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
+        yield AcpcPokerTypes::Card.from_components(rank, suit)
       end
     end
   end
   def for_every_two_cards!
-    for_every_card do |first_card| 
+    for_every_card do |first_card|
       for_every_card do |second_card|
         @string = first_card.to_s + second_card.to_s
         @acpc = first_card.to_acpc + second_card.to_acpc

data/spec/match_definition_spec.rb

@@ -0,0 +1,95 @@
+
+# Spec helper (must include first to track code coverage with SimpleCov)
+require_relative 'support/spec_helper'
+
+require 'acpc_poker_types/game_definition'
+require 'acpc_dealer'
+
+require 'acpc_poker_types/acpc_dealer_data/match_definition'
+
+describe AcpcPokerTypes::AcpcDealerData::MatchDefinition do
+  before do
+    @name = nil
+    @game_def = nil
+    @number_of_hands = nil
+    @random_seed = nil
+    @player_names = nil
+    @patient = nil
+  end
+
+  it 'raises an exception if the number of player names does not match the number of players' do
+    init_components do
+      ->() do
+        @patient = AcpcPokerTypes::AcpcDealerData::MatchDefinition.new(
+          @name,
+          @game_def,
+          @number_of_hands,
+          @random_seed,
+          @player_names + ['extra player']
+        )
+      end.must_raise AcpcPokerTypes::AcpcDealerData::MatchDefinition::IncorrectNumberOfPlayerNames
+
+      ->() do
+        @patient = AcpcPokerTypes::AcpcDealerData::MatchDefinition.new(
+          @name,
+          @game_def,
+          @number_of_hands,
+          @random_seed,
+          [@player_names.first]
+        )
+      end.must_raise AcpcPokerTypes::AcpcDealerData::MatchDefinition::IncorrectNumberOfPlayerNames
+    end
+  end
+
+  describe 'can be created by providing components' do
+    it 'separately' do
+      init_components do
+        @patient = AcpcPokerTypes::AcpcDealerData::MatchDefinition.new(
+          @name,
+          @game_def,
+          @number_of_hands,
+          @random_seed,
+          @player_names
+        )
+
+        check_patient
+      end
+    end
+    it 'in string format "# name/game/hands/seed ..."' do
+      init_components do
+        string = "# name/game/hands/seed #{@name} #{@game_def_file_name} #{@number_of_hands} #{@random_seed}\n"
+        @patient = AcpcPokerTypes::AcpcDealerData::MatchDefinition.parse(string, @player_names, File.dirname(@game_def_file_name))
+
+        check_patient
+      end
+    end
+  end
+  it 'returns nil if asked to parse an improperly formatted string' do
+    string = 'improperly formatted string'
+    @patient = AcpcPokerTypes::AcpcDealerData::MatchDefinition.parse(string, ['p1', 'p2'], 'game def directory').must_be_nil
+  end
+
+  def init_components
+    @name = 'match_name'
+    AcpcDealer::GAME_DEFINITION_FILE_PATHS.each do |number_of_players, game_def_hash|
+      game_def_hash.each do |betting_type, file_name|
+        @game_def_file_name = file_name
+        @game_def = AcpcPokerTypes::GameDefinition.parse_file(@game_def_file_name)
+        @number_of_hands = 100
+        @random_seed = 9001
+        @player_names = number_of_players.times.inject([]) do |names, i|
+          names << "p#{i}"
+        end
+
+        yield
+      end
+    end
+  end
+  def check_patient
+    @patient.name.must_equal @name
+    Set.new(@patient.game_def.to_a).must_equal Set.new(@game_def.to_a)
+    @patient.number_of_hands.must_equal @number_of_hands
+    @patient.random_seed.must_equal @random_seed
+    @patient.player_names.must_equal @player_names
+  end
+end

data/spec/match_state_spec.rb

@@ -2,11 +2,14 @@
 # Spec helper (must include first to track code coverage with SimpleCov)
 require File.expand_path('../support/spec_helper', __FILE__)
 
-require "#{LIB_ACPC_POKER_TYPES_PATH}/board_cards"
-require "#{LIB_ACPC_POKER_TYPES_PATH}/match_state"
-require "#{LIB_ACPC_POKER_TYPES_PATH}/poker_action"
-
-describe MatchState do
+require "acpc_poker_types/match_state"
+require "acpc_poker_types/poker_action"
+require "acpc_poker_types/rank"
+require "acpc_poker_types/suit"
+require "acpc_poker_types/hand"
+require "acpc_poker_types/card"
+
+describe AcpcPokerTypes::MatchState do
   describe '#parse' do
     describe 'raises an exception if ' do
       describe 'the raw matchstate string' do
@@ -19,29 +22,29 @@ describe MatchState do
         end
 
         it 'does not contain a position' do
-          test_match_state_initialization_error MatchState::LABEL + "::0::AhKd"
+          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + "::0::AhKd"
         end
 
         it 'does not contain a hand number' do
-          test_match_state_initialization_error MatchState::LABEL + ":0:::AsKc"
+          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + ":0:::AsKc"
         end
 
         it 'does not contain cards' do
-          test_match_state_initialization_error MatchState::LABEL + ":0:0::"
+          test_match_state_initialization_error AcpcPokerTypes::MatchState::LABEL + ":0:0::"
         end
       end
     end
     it "parses every possible limit action" do
-      partial_match_state = MatchState::LABEL + ":1:1:"
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":1:1:"
       hole_cards = arbitrary_hole_card_hand
-      PokerAction::LEGAL_ACPC_CHARACTERS.each do |action|
+      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |action|
         match_state = partial_match_state + action + ":" + hole_cards.to_acpc
         patient = test_match_state_success match_state
-        patient.last_action.to_acpc.should be == action
+        patient.last_action.to_acpc.must_equal action
       end
     end
     it "parses every possible hole card hand" do
-      partial_match_state = MatchState::LABEL + ":2:2::"
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + hand.to_acpc + '|'
 
@@ -49,7 +52,7 @@ describe MatchState do
       end
     end
     it "parses opponent hole card hands in a two player game where the user is not the dealer" do
-      partial_match_state = MatchState::LABEL + ":0:2::"
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":0:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + arbitrary_hole_card_hand.to_acpc + '|' + hand.to_acpc
 
@@ -57,11 +60,11 @@ describe MatchState do
 
         (patient.list_of_opponents_hole_cards.map do |opponent_hand|
           opponent_hand.to_acpc
-        end).should be == [hand.to_acpc]
+        end).must_equal [hand.to_acpc]
       end
     end
     it "parses opponent hole card hands in a two player game where the user is the dealer" do
-      partial_match_state = MatchState::LABEL + ":1:2::"
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":1:2::"
       for_every_hand do |hand|
         match_state = partial_match_state + hand.to_acpc + '|' + arbitrary_hole_card_hand.to_acpc
 
@@ -69,50 +72,40 @@ describe MatchState do
 
         (patient.list_of_opponents_hole_cards.map do |opponent_hand|
            opponent_hand.to_acpc
-        end).should be == [hand.to_acpc]
+        end).must_equal [hand.to_acpc]
       end
     end
     it 'parses board cards properly for the flop' do
-      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
 
       board_cards = '/AhKdQc'
       flop_match_state = partial_match_state + board_cards
 
-      patient = MatchState.parse flop_match_state
+      patient = AcpcPokerTypes::MatchState.parse flop_match_state
 
-      patient.board_cards.to_acpc.should be == board_cards
+      patient.board_cards.to_acpc.must_equal board_cards
     end
     it 'parses board cards properly for the turn' do
-      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
       board_cards = '/AhKdQc/Jd'
       turn_match_state = partial_match_state + board_cards
 
-      patient = MatchState.parse turn_match_state
+      patient = AcpcPokerTypes::MatchState.parse turn_match_state
 
-      patient.board_cards.to_acpc.should be == board_cards
+      patient.board_cards.to_acpc.must_equal board_cards
     end
     it 'parses board cards properly for the river' do
-      partial_match_state = MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":2:2::" + arbitrary_hole_card_hand.to_acpc
       board_cards = '/AhKdQc/Jd/Th'
       river_match_state = partial_match_state + board_cards
 
-      patient = MatchState.parse river_match_state
-
-      patient.board_cards.to_acpc.should be == board_cards
-    end
-    it "parses valid limit match states in all rounds" do
-      pending 'need to look at this test'
-
-      test_all_rounds_with_given_action_string PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
-    end
-    it "parses valid no-limit match states in all rounds" do
-      pending 'need to look at this test'
+      patient = AcpcPokerTypes::MatchState.parse river_match_state
 
-      test_all_rounds_with_given_action_string PokerAction::LEGAL_ACTIONS[:raise], 1
+      patient.board_cards.to_acpc.must_equal board_cards
     end
     it "parses a valid two player final match state" do
-      partial_match_state = MatchState::LABEL + ":20:22:"
-      all_actions = PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
+      all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
@@ -120,14 +113,14 @@ describe MatchState do
       end
       board_cards = arbitrary_roll_out number_of_rounds
       hands = arbitrary_hole_card_hand.to_acpc + "|" + arbitrary_hole_card_hand.to_acpc
-      
+
       match_state = partial_match_state + betting + ":" + hands + board_cards
 
       test_match_state_success match_state
     end
     it "parses a valid three player final match state" do
-      partial_match_state = MatchState::LABEL + ":20:22:"
-      all_actions = PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
+      all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
@@ -136,7 +129,7 @@ describe MatchState do
       board_cards = arbitrary_roll_out number_of_rounds
       hands = arbitrary_hole_card_hand.to_s + "|" +
         arbitrary_hole_card_hand.to_s + "|" + arbitrary_hole_card_hand.to_s
-      
+
       match_state = partial_match_state + betting + ":" + hands + board_cards
 
       test_match_state_success match_state
@@ -145,13 +138,13 @@ describe MatchState do
 
   describe '#round' do
     it "properly reports the current round number" do
-      partial_match_state = MatchState::LABEL + ":0:0:"
+      partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":0:0:"
       betting = ""
       hand = arbitrary_hole_card_hand
       100.times do |i|
         match_state = partial_match_state + betting + ':|' + hand
         patient = test_match_state_success match_state
-        patient.round.should be == i
+        patient.round.must_equal i
 
         betting += "c/"
       end
@@ -170,287 +163,112 @@ describe MatchState do
         end
         hands.push arbitrary_hole_card_hand.to_acpc
       end
-      match_state = MatchState::LABEL + ':1:1::' + hands.join('|')
+      match_state = AcpcPokerTypes::MatchState::LABEL + ':1:1::' + hands.join('|')
 
       patient = test_match_state_success match_state
-      patient.number_of_players.should be == expected_number_of_players
+      patient.number_of_players.must_equal expected_number_of_players
     end
   end
 
   describe '#last_action, #round_in_which_last_action_taken, and #first_state_of_first_round' do
     it 'returns +nil+ if no previous action exists, or true in the case of #first_state_of_first_round' do
-      initial_match_state = "#{MatchState::LABEL}:1:1::#{arbitrary_hole_card_hand}"
-      patient = MatchState.parse initial_match_state
-      patient.last_action.should == nil
-      patient.round_in_which_last_action_taken.should == nil
-      patient.first_state_of_first_round?.should == true
+      initial_match_state = "#{AcpcPokerTypes::MatchState::LABEL}:1:1::#{arbitrary_hole_card_hand}"
+      patient = AcpcPokerTypes::MatchState.parse initial_match_state
+      patient.last_action.must_be_nil
+      patient.round_in_which_last_action_taken.must_be_nil
+      patient.first_state_of_first_round?.must_equal true
     end
     it 'works properly if a previous action exists' do
-      PokerAction::LEGAL_ACPC_CHARACTERS.each do |first_action|
-        PokerAction::LEGAL_ACPC_CHARACTERS.each do |second_action|
-          PokerAction::LEGAL_ACPC_CHARACTERS.each do |third_action|
-            partial_match_state = "#{MatchState::LABEL}:1:1:"
+      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |first_action|
+        AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |second_action|
+          AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |third_action|
+            partial_match_state = "#{AcpcPokerTypes::MatchState::LABEL}:1:1:"
 
             partial_match_state += first_action
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = MatchState.parse match_state
-            patient.last_action.should be == PokerAction.new(first_action)
-            patient.round_in_which_last_action_taken.should == 0
-            patient.first_state_of_first_round?.should == false
+            patient = AcpcPokerTypes::MatchState.parse match_state
+            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(first_action)
+            patient.round_in_which_last_action_taken.must_equal 0
+            patient.first_state_of_first_round?.must_equal false
 
             partial_match_state += "#{second_action}/"
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = MatchState.parse match_state
-            patient.last_action.should be == PokerAction.new(second_action)
-            patient.round_in_which_last_action_taken.should == 0
-            patient.first_state_of_first_round?.should == false
+            patient = AcpcPokerTypes::MatchState.parse match_state
+            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(second_action)
+            patient.round_in_which_last_action_taken.must_equal 0
+            patient.first_state_of_first_round?.must_equal false
 
             partial_match_state += third_action
             match_state = "#{partial_match_state}:#{arbitrary_hole_card_hand}"
 
-            patient = MatchState.parse match_state
-            patient.last_action.should be == PokerAction.new(third_action)
-            patient.round_in_which_last_action_taken.should == 1
-            patient.first_state_of_first_round?.should == false
+            patient = AcpcPokerTypes::MatchState.parse match_state
+            patient.last_action.must_equal AcpcPokerTypes::PokerAction.new(third_action)
+            patient.round_in_which_last_action_taken.must_equal 1
+            patient.first_state_of_first_round?.must_equal false
           end
         end
       end
     end
   end
+end
 
-  # @param [Integer] An amount to append to actions.  If none is given,
-  #  +raise_amount+ defaults to an empty string.
-  def test_all_rounds_with_given_action_string(action_string, raise_amount='')
-    partial_match_state = MatchState::LABEL + ":1:0:"
-
-    users_hole_cards = arbitrary_hole_card_hand
-    list_of_opponents_hole_cards = [[]]
-
-    (betting_string, list_of_betting_actions) = generate_betting_sequence action_string + raise_amount.to_s
-    number_of_actions_this_round = list_of_betting_actions.length
-
-    list_of_board_cards = []
-    board_cards_string = ""
-
-    number_of_rounds = 100
-    (1..number_of_rounds-1).each do |round|
-      match_state = partial_match_state + betting_string + ":|#{users_hole_cards}#{board_cards_string}"
-
-      round_index = round - 1
-
-      test_full_information(match_state, list_of_betting_actions,
-                            last_action(list_of_betting_actions), users_hole_cards,
-                            list_of_opponents_hole_cards, list_of_board_cards, round_index,
-                            number_of_actions_this_round)
-
-      # Make an interesting raise amount if the caller specified a raise amount in the first place
-      raise_amount += 10**round + round*3 unless raise_amount.to_s.empty?
-
-      betting_string = generate_betting_sequence(
-        betting_string,
-        list_of_betting_actions, 
-        action_string + raise_amount.to_s
-      )
-
-      list_of_board_cards << (if round > 1 
-        (round+1).to_s + Suit::DOMAIN[:spades][:acpc_character] 
-      else 
-        arbitrary_flop 
-      end)
-      board_cards_string += "/" + list_of_board_cards[round]
-    end
-  end
-
-  def for_every_card
-    Rank::DOMAIN.map do |rank, rank_properties|
-      Suit::DOMAIN.map do |suit, suit_properties|
-        yield Card.from_components(rank, suit)
-      end
-    end
-  end
-  def for_every_hand
-    for_every_card do |first_card|
-      for_every_card do |second_card|
-        yield Hand.draw_cards(first_card, second_card)
-      end
-    end
-  end
-
-  def generate_betting_sequence(betting_string = "", list_of_betting_actions = [], action_string)
-    betting_string += if betting_string.empty?
-      action_string
-    else
-      "/#{action_string}"
-    end
-    (list_of_betting_actions << action_string.scan(/[^\/]\d*/)).flatten!
-
-    [betting_string, list_of_betting_actions]
-  end
-
-  def last_action(list_of_betting_actions)
-    list_of_betting_actions[-1]
-  end
-
-  def test_full_information(match_state, list_of_betting_actions,
-                            last_action, users_hole_cards, list_of_opponents_hole_cards,
-                            list_of_board_cards, round, number_of_actions_this_round)
-
-    patient = test_match_state_success match_state
-
-    patient.betting_sequence.should be == list_of_betting_actions
-    patient.last_action.should be == last_action
-    patient.users_hole_cards.to_s.should be == users_hole_cards.to_s
-    patient.list_of_opponents_hole_cards.should be == list_of_opponents_hole_cards
-    (if patient.board_cards.join.empty? then [] else [patient.board_cards.join] end).should be == list_of_board_cards
-    patient.round.should be == round
-    patient.number_of_actions_this_round.should be == number_of_actions_this_round
-  end
-
-  def test_match_state_initialization_error(incomplete_match_state)
-    expect{MatchState.parse incomplete_match_state}.to raise_exception(MatchState::IncompleteMatchState)
-  end
-  def test_match_state_success(match_state)
-    patient = MatchState.parse match_state
-    patient.to_s.should be == match_state
-
-    patient
-  end
-  def arbitrary_flop
-    flop = ""
-    rank = 2
-    (Suit::DOMAIN.values.map { |suit| suit[:acpc_character] }).each do |suit|
-      flop += rank.to_s + suit unless Suit::DOMAIN[:clubs][:acpc_character] == suit
-      rank += 1
+def for_every_card
+  AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
+    AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
+      yield AcpcPokerTypes::Card.from_components(rank, suit)
     end
-    flop
   end
-
-  def arbitrary_roll_out(rounds)
-    board_cards = ""
-    (1..rounds-1).each do |round|
-      board_cards += "/" + if round > 1
-        '2' + Suit::DOMAIN[:spades][:acpc_character]
-      else
-        arbitrary_flop
-      end
+end
+def for_every_hand
+  for_every_card do |first_card|
+    for_every_card do |second_card|
+      yield AcpcPokerTypes::Hand.draw_cards(first_card, second_card)
     end
-
-    board_cards
   end
+end
 
+def test_match_state_initialization_error(incomplete_match_state)
+  ->{AcpcPokerTypes::MatchState.parse incomplete_match_state}.must_raise(AcpcPokerTypes::MatchState::IncompleteMatchState)
+end
+def test_match_state_success(match_state)
+  patient = AcpcPokerTypes::MatchState.parse match_state
+  patient.to_s.must_equal match_state
 
-
-
-
-
-  ##########
-  # Initialization methods ---------------------------------------------------
-  def create_initial_match_state(number_of_players=2)
-    user_position = 1;
-    hand_number = 0
-    hole_card_hand = arbitrary_hole_card_hand
-    initial_match_state = mock('MatchState')
-    initial_match_state.stubs(:position_relative_to_dealer).returns(user_position)
-    initial_match_state.stubs(:hand_number).returns(hand_number)
-    initial_match_state.stubs(:list_of_board_cards).returns([])
-    initial_match_state.stubs(:list_of_betting_actions).returns([])
-    initial_match_state.stubs(:users_hole_cards).returns(hole_card_hand)
-    initial_match_state.stubs(:list_of_opponents_hole_cards).returns([])
-    initial_match_state.stubs(:list_of_hole_card_hands).returns(list_of_hole_card_hands(user_position, hole_card_hand, number_of_players))
-    initial_match_state.stubs(:last_action).returns(nil)
-    initial_match_state.stubs(:round).returns(0)
-    initial_match_state.stubs(:number_of_actions_in_current_round).returns(0)
-
-    raw_match_state =  MatchState::LABEL + ":#{user_position}:#{hand_number}::" + hole_card_hand
-    initial_match_state.stubs(:to_s).returns(raw_match_state)
-
-    [initial_match_state, user_position]
+  patient
+end
+def arbitrary_flop
+  flop = ""
+  rank = 2
+  (AcpcPokerTypes::Suit::DOMAIN.values.map { |suit| suit[:acpc_character] }).each do |suit|
+    flop += rank.to_s + suit unless AcpcPokerTypes::Suit::DOMAIN[:clubs][:acpc_character] == suit
+    rank += 1
   end
+  flop
+end
 
-  def list_of_hole_card_hands(user_position, user_hole_card_hand, number_of_players)
-    number_of_entries_in_the_list = number_of_players - (if user_position == number_of_players - 1
-      1
+def arbitrary_roll_out(rounds)
+  board_cards = ""
+  (1..rounds-1).each do |round|
+    board_cards += "/" + if round > 1
+      '2' + AcpcPokerTypes::Suit::DOMAIN[:spades][:acpc_character]
     else
-      2
-    end)
-
-    number_of_entries_in_the_list.times.inject([]) do |i|
-      hole_card_sets << (if i == user_position then user_hole_card_hand else '' end)
+      arbitrary_flop
     end
   end
 
-  def create_game_definition
-    game_definition = mock('GameDefinition')
-    game_definition.stubs(:number_of_players).returns(3)
-    game_definition.stubs(:minimum_wager_in_each_round).returns([10, 10, 20, 20])
-    game_definition.stubs(:first_player_position_in_each_round).returns([2, 1, 1, 1])
-    game_definition.stubs(:max_raise_in_each_round).returns([3, 4, 4, 4])
-    game_definition.stubs(:list_of_player_stacks).returns([20000, 20000, 20000])
-    game_definition.stubs(:big_blind).returns(10)
-    game_definition.stubs(:small_blind).returns(5)
-
-    game_definition
-  end
-
-  def create_player_manager(game_definition)
-    player_manager = mock('PlayerManager')
-
-    (player_who_submitted_big_blind, player_who_submitted_small_blind, other_player) = create_players game_definition.big_blind, game_definition.small_blind
-
-    player_manager.stubs(:player_who_submitted_big_blind).returns(player_who_submitted_big_blind)
-    player_manager.stubs(:player_who_submitted_small_blind).returns(player_who_submitted_small_blind)
-    player_manager.stubs(:players_who_did_not_submit_a_blind).returns([other_player])
-
-    list_of_player_stacks = game_definition.list_of_player_stacks.dup
-    player_manager.stubs(:list_of_player_stacks).returns(list_of_player_stacks)
-
-    player_manager
-  end
-
-  def create_players(big_blind, small_blind)
-    player_who_submitted_big_blind = mock('Player')
-    player_who_submitted_big_blind.stubs(:current_wager_faced=).with(0)
-    player_who_submitted_big_blind.stubs(:current_wager_faced).returns(0)
-    player_who_submitted_big_blind.stubs(:name).returns('big_blind_player')
-
-    player_who_submitted_small_blind = mock('Player')
-    player_who_submitted_small_blind.stubs(:current_wager_faced=).with(big_blind - small_blind)
-    player_who_submitted_small_blind.stubs(:current_wager_faced).returns(big_blind - small_blind)
-    player_who_submitted_small_blind.stubs(:name).returns('small_blind_player')
-
-    other_player = mock('Player')
-    other_player.stubs(:current_wager_faced=).with(big_blind)
-    other_player.stubs(:current_wager_faced).returns(big_blind)
-    other_player.stubs(:name).returns('other_player')
-
-    [player_who_submitted_big_blind, player_who_submitted_small_blind, other_player]
-  end
-
-  def setup_action_test(match_state, action_type, action_argument = '')
-    action = action_argument + action_type
-    expected_string = raw_match_state match_state, action
-
-    expected_string
-  end
-
-
-  # Helper methods -----------------------------------------------------------
-
-  def raw_match_state(match_state, action)
-    "#{match_state}:#{action}"
-  end
-
-  # Construct an arbitrary hole card hand.
-  #
-  # @return [Mock Hand] An arbitrary hole card hand.
-  def arbitrary_hole_card_hand
-    Hand.from_acpc(
-      Rank::DOMAIN[:two][:acpc_character] +
-      Suit::DOMAIN[:spades][:acpc_character] +
-      Rank::DOMAIN[:three][:acpc_character] +
-      Suit::DOMAIN[:hearts][:acpc_character]
-    )
-  end
+  board_cards
 end
+
+# Construct an arbitrary hole card hand.
+#
+# @return [Mock AcpcPokerTypes::Hand] An arbitrary hole card hand.
+def arbitrary_hole_card_hand
+  AcpcPokerTypes::Hand.from_acpc(
+    AcpcPokerTypes::Rank::DOMAIN[:two][:acpc_character] +
+    AcpcPokerTypes::Suit::DOMAIN[:spades][:acpc_character] +
+    AcpcPokerTypes::Rank::DOMAIN[:three][:acpc_character] +
+    AcpcPokerTypes::Suit::DOMAIN[:hearts][:acpc_character]
+  )
+end