Pool order tests are not asserting properly and once fixed some were failing. All tests fixed and passing now.

app/models/wrestler.rb

@@ -226,10 +226,29 @@ class Wrestler < ActiveRecord::Base
 		points_scored
 	end
 	
+	def decision_points_scored_pool
+		points_scored = 0
+		decision_wins.select{|m| m.bracket_position == "Pool"}.each do |m|
+			score_of_match = m.score.delete(" ")
+			score_one = score_of_match.partition('-').first.to_i
+			score_two = score_of_match.partition('-').last.to_i
+			if score_one > score_two
+				points_scored = points_scored + score_one
+			elsif score_two > score_one
+				points_scored = points_scored + score_two
+			end
+		end
+		points_scored
+	end
+	
 	def fastest_pin
 		pin_wins.sort_by{|m| m.pin_time_in_seconds}.first
 	end
 	
+	def fastest_pin_pool
+		pin_wins.select{|m| m.bracket_position == "Pool"}.sort_by{|m| m.pin_time_in_seconds}.first
+	end
+
 	def pin_time
       time = 0
       pin_wins.each do | m |
@@ -238,6 +257,14 @@ class Wrestler < ActiveRecord::Base
       time
 	end
 	
+	def pin_time_pool
+      time = 0
+      pin_wins.select{|m| m.bracket_position == "Pool"}.each do | m |
+      	time = time + m.pin_time_in_seconds
+      end
+      time
+	end
+	
 	def season_win_percentage
 		win = self.season_win.to_f
 		loss = self.season_loss.to_f

app/services/bracket_advancement/pool_order.rb

@@ -5,17 +5,26 @@ class PoolOrder
 
 	def getPoolOrder
 	    setOriginalPoints
-	    while checkForTieBreakers == true
+	    while checkForTies(@wrestlers) == true
-	        breakTie
+	        getWrestlersOrderByPoolAdvancePoints.each do |wrestler|
+	        	wrestlers_with_same_points = getWrestlersOrderByPoolAdvancePoints.select{|w| w.poolAdvancePoints == wrestler.poolAdvancePoints}
+	        	if wrestlers_with_same_points.size > 1
+	        		breakTie(wrestlers_with_same_points)
+	        	end
+	        end
 	    end
-	    @wrestlers.sort_by{|w| w.poolAdvancePoints}.reverse.each_with_index do |wrestler, index|
+	    getWrestlersOrderByPoolAdvancePoints.each_with_index do |wrestler, index|
-          placement = index + 1
+            placement = index + 1
-          wrestler.pool_placement = placement
+            wrestler.pool_placement = placement
-          wrestler.save
+            wrestler.save
 	    end
 	    @wrestlers.sort_by{|w| w.poolAdvancePoints}.reverse!
 	end
 	
+	def getWrestlersOrderByPoolAdvancePoints
+	    @wrestlers.sort_by{|w| w.poolAdvancePoints}.reverse	
+	end
+	
 	def setOriginalPoints
 	   @wrestlers.each do |w|
 	   	   w.pool_placement_tiebreaker = nil
@@ -24,16 +33,16 @@ class PoolOrder
 	   end
 	end
 	
-	def checkForTieBreakers
+	def checkForTies(wrestlers_to_check)
-	    if wrestlersWithSamePoints.size > 1
+	    if wrestlersWithSamePoints(wrestlers_to_check).size > 1
 	       return true
 	    end
 	    return false
 	end
 	
-	def wrestlersWithSamePoints
+	def wrestlersWithSamePoints(wrestlers_to_check)
-		@wrestlers.each do |w|
+		wrestlers_to_check.each do |w|
-	       wrestlersWithSamePointsLocal = @wrestlers.select{|wr| wr.poolAdvancePoints == w.poolAdvancePoints}
+	       wrestlersWithSamePointsLocal = wrestlers_to_check.select{|wr| wr.poolAdvancePoints == w.poolAdvancePoints}
 	       if wrestlersWithSamePointsLocal.size > 1
 	       	 return wrestlersWithSamePointsLocal
 	       end
@@ -41,34 +50,34 @@ class PoolOrder
 	    return []
 	end
 	
-	def ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+	def ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_to_check)
-		if wrestlersWithSamePoints.size == originalTieSize
+		if wrestlersWithSamePoints(wrestlers_to_check).size == originalTieSize
 			return true
 		else 
 		    return false	
 		end
 	end
 	
-	def breakTie
+	def breakTie(wrestlers_with_same_points)
-		originalTieSize = wrestlersWithSamePoints.size
+		originalTieSize = wrestlers_with_same_points.size
-		deductedPoints(originalTieSize) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		deductedPoints(originalTieSize,wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
 		if originalTieSize == 2
-	    	headToHead if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+	    	headToHead(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
 		end
-		teamPoints if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		teamPoints(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-        mostFalls if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+        mostFalls(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-		mostTechs if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		mostTechs(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-		mostMajors if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		mostMajors(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-		mostDecisionPointsScored if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		mostDecisionPointsScored(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-		fastest_pins if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		fastest_pins(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
-		coinFlip if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize)
+		coinFlip(wrestlers_with_same_points) if ifWrestlersWithSamePointsIsSameAsOriginal(originalTieSize,wrestlers_with_same_points)
 	end
 	
 	
-	def headToHead
+	def headToHead(wrestlers_with_same_points)
-	   wrestlersWithSamePoints.each do |wr|
+	   wrestlers_with_same_points.each do |wr|
-	        otherWrestler = wrestlersWithSamePoints.select{|w| w.id != wr.id}.first
+	        otherWrestler = wrestlers_with_same_points.select{|w| w.id != wr.id}.first
-	        if otherWrestler and wr.match_against(otherWrestler).first.winner_id == wr.id
+	        if otherWrestler and wr.match_against(otherWrestler).select{|match| match.bracket_position == "Pool"}.first.winner_id == wr.id
 	        	addPointsToWrestlersAhead(wr)
 	        	wr.pool_placement_tiebreaker = "Head to Head"
 	            addPoints(wr)
@@ -77,6 +86,8 @@ class PoolOrder
 	end
 	
 	def addPoints(wrestler)
+		# addPointsToWrestlersAhead(wrestler)
+		# Cannot go here because if team points are the same the first with points added will stay ahead
 		wrestler.poolAdvancePoints = wrestler.poolAdvancePoints + 1
 	end
 	
@@ -87,13 +98,13 @@ class PoolOrder
 		end
 	end
 	
-	def deductedPoints(originalTieSize)
+	def deductedPoints(originalTieSize,wrestlers_with_same_points)
 		pointsArray = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
 			pointsArray << w.total_points_deducted
 		end
 		leastPoints = pointsArray.min
-		wrestlersWithLeastDeductedPoints = wrestlersWithSamePoints.select{|w| w.total_points_deducted == leastPoints}
+		wrestlersWithLeastDeductedPoints = wrestlers_with_same_points.select{|w| w.total_points_deducted == leastPoints}
 		addPointsToWrestlersAhead(wrestlersWithLeastDeductedPoints.first)
 		if wrestlersWithLeastDeductedPoints.size != originalTieSize
 			wrestlersWithLeastDeductedPoints.each do |wr|
@@ -103,38 +114,37 @@ class PoolOrder
 		end
 	end
 	
-	def mostDecisionPointsScored
+	def mostDecisionPointsScored(wrestlers_with_same_points)
 		pointsArray = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
-			pointsArray << w.decision_points_scored
+			pointsArray << w.decision_points_scored_pool
 		end
 		mostPoints = pointsArray.max
-		wrestlersWithMostPoints = wrestlersWithSamePoints.select{|w| w.decision_points_scored == mostPoints}
+		wrestlersWithMostPoints = wrestlers_with_same_points.select{|w| w.decision_points_scored_pool == mostPoints}
 		addPointsToWrestlersAhead(wrestlersWithMostPoints.first)
 		wrestlersWithMostPoints.each do |wr|
-			wr.pool_placement_tiebreaker = "Points Scored"
+			wr.pool_placement_tiebreaker = "Decision Points Scored"
 			addPoints(wr)
 		end
 		secondPoints = pointsArray.sort[-2]
-		wrestlersWithSecondMostPoints = wrestlersWithSamePoints.select{|w| w.decision_points_scored == secondPoints}
+		wrestlersWithSecondMostPoints = wrestlers_with_same_points.select{|w| w.decision_points_scored_pool == secondPoints}
 		addPointsToWrestlersAhead(wrestlersWithSecondMostPoints.first)
 		wrestlersWithSecondMostPoints.each do |wr|
-			wr.pool_placement_tiebreaker = "Points Scored"
+			wr.pool_placement_tiebreaker = "Decision Points Scored"
 			addPoints(wr)
 		end
 	end
 	
-	def fastest_pins
+	def fastest_pins(wrestlers_with_same_points)
 		wrestlersWithSamePointsWithPins = []
-		wrestlersWithSamePoints.each do |wr|
+		wrestlers_with_same_points.each do |wr|
-			if wr.pin_wins.size > 0
+			if wr.pin_wins.select{|m| m.bracket_position == "Pool"}.size > 0
 				wrestlersWithSamePointsWithPins << wr	
 			end
 		end
 		if wrestlersWithSamePointsWithPins.size > 0
-			fastest = wrestlersWithSamePointsWithPins.sort_by{|w| w.fastest_pin.pin_time_in_seconds}.first.fastest_pin
+			fastest = wrestlersWithSamePointsWithPins.sort_by{|w| w.pin_time_pool}.first.pin_time_pool
-			secondFastest = wrestlersWithSamePointsWithPins.sort_by{|w| w.fastest_pin.pin_time_in_seconds}.second.fastest_pin
+			wrestlersWithFastestPin = wrestlersWithSamePointsWithPins.select{|w| w.pin_time_pool == fastest}
-			wrestlersWithFastestPin = wrestlersWithSamePointsWithPins.select{|w| w.fastest_pin.pin_time_in_seconds == fastest.pin_time_in_seconds}
 			addPointsToWrestlersAhead(wrestlersWithFastestPin.first)
 			wrestlersWithFastestPin.each do |wr|
 				wr.pool_placement_tiebreaker = "Pin Time"
@@ -143,13 +153,13 @@ class PoolOrder
 		end
 	end
 	
-	def teamPoints
+	def teamPoints(wrestlers_with_same_points)
-		pointsArray = []
+		teamPointsArray = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
-			pointsArray << w.total_pool_points_for_pool_order
+			teamPointsArray << w.total_pool_points_for_pool_order
 		end
-		mostPoints = pointsArray.max
+		mostPoints = teamPointsArray.max
-		wrestlersSortedByTeamPoints = wrestlersWithSamePoints.select{|w| w.total_pool_points_for_pool_order == mostPoints}
+		wrestlersSortedByTeamPoints = wrestlers_with_same_points.select{|w| w.total_pool_points_for_pool_order == mostPoints}
 		addPointsToWrestlersAhead(wrestlersSortedByTeamPoints.first)
 		wrestlersSortedByTeamPoints.each do |wr|
 			wr.pool_placement_tiebreaker = "Team Points"
@@ -157,50 +167,56 @@ class PoolOrder
 		end	
 	end
 	
-	def mostFalls
+	def mostFalls(wrestlers_with_same_points)
-		pointsArray = []
+		mostPins = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
-			pointsArray << w.pin_wins.size
+			mostPins << w.pin_wins.select{|m| m.bracket_position == "Pool"}.size
 		end
-		mostPoints = pointsArray.max
+		pinsMax = mostPins.max
-		wrestlersSortedByFallWins = wrestlersWithSamePoints.select{|w| w.pin_wins.size == mostPoints}
+		wrestlersSortedByFallWins = wrestlers_with_same_points.select{|w| w.pin_wins.select{|m| m.bracket_position == "Pool"}.size == pinsMax}
-		addPointsToWrestlersAhead(wrestlersSortedByFallWins.first)
+		if pinsMax > 0
-		wrestlersSortedByFallWins.each do |wr|
+			addPointsToWrestlersAhead(wrestlersSortedByFallWins.first)
-			wr.pool_placement_tiebreaker = "Most Pins"
+			wrestlersSortedByFallWins.each do |wr|
-			addPoints(wr)	
+				wr.pool_placement_tiebreaker = "Most Pins"
+				addPoints(wr)	
+			end
 		end
 	end
 	
-	def mostTechs
+	def mostTechs(wrestlers_with_same_points)
-		pointsArray = []
+		techsArray = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
-			pointsArray << w.tech_wins.size
+			techsArray << w.tech_wins.select{|m| m.bracket_position == "Pool"}.size
 		end
-		mostPoints = pointsArray.max
+		mostTechsWins = techsArray.max
-		wrestlersSortedByTechWins = wrestlersWithSamePoints.select{|w| w.tech_wins.size == mostPoints}
+		wrestlersSortedByTechWins = wrestlers_with_same_points.select{|w| w.tech_wins.select{|m| m.bracket_position == "Pool"}.size == mostTechsWins}
-		addPointsToWrestlersAhead(wrestlersSortedByTechWins.first)
+		if mostTechsWins > 0
-		wrestlersSortedByTechWins.each do |wr|
+			addPointsToWrestlersAhead(wrestlersSortedByTechWins.first)
-			wr.pool_placement_tiebreaker = "Most Techs"
+			wrestlersSortedByTechWins.each do |wr|
-			addPoints(wr)	
+				wr.pool_placement_tiebreaker = "Most Techs"
+				addPoints(wr)	
+			end
 		end
 	end
 	
-	def mostMajors
+	def mostMajors(wrestlers_with_same_points)
-		pointsArray = []
+		majorsArray = []
-		wrestlersWithSamePoints.each do |w|
+		wrestlers_with_same_points.each do |w|
-			pointsArray << w.major_wins.size
+			majorsArray << w.major_wins.select{|m| m.bracket_position == "Pool"}.size
 		end
-		mostPoints = pointsArray.max
+		mostMajorWins = majorsArray.max
-		wrestlersSortedByMajorWins = wrestlersWithSamePoints.select{|w| w.major_wins.size == mostPoints}
+		wrestlersSortedByMajorWins = wrestlers_with_same_points.select{|w| w.major_wins.select{|m| m.bracket_position == "Pool"}.size == mostMajorWins}
-		addPointsToWrestlersAhead(wrestlersSortedByMajorWins.first)
+		if mostMajorWins > 0
-		wrestlersSortedByMajorWins.each do |wr|
+			addPointsToWrestlersAhead(wrestlersSortedByMajorWins.first)
-			wr.pool_placement_tiebreaker = "Most Majors"
+			wrestlersSortedByMajorWins.each do |wr|
-			addPoints(wr)	
+				wr.pool_placement_tiebreaker = "Most Majors"
+				addPoints(wr)	
+			end	
 		end
 	end
 	
-	def coinFlip
+	def coinFlip(wrestlers_with_same_points)
-		wrestler = wrestlersWithSamePoints.sample
+		wrestler = wrestlers_with_same_points.sample
 		wrestler.pool_placement_tiebreaker = "Coin Flip"
 		addPointsToWrestlersAhead(wrestler)
 	    addPoints(wrestler)

test/integration/pool_order_test.rb

@@ -6,412 +6,466 @@ class PoolAdvancementTest < ActionDispatch::IntegrationTest
     create_pool_tournament_single_weight(6)
   end
 
-  def finishWithNoTies
+  test "Pool order based on wins" do
-    end_match(match_wrestler_vs("Test1","Test2"),"Test1")
+  	end_match(match_wrestler_vs("Test1","Test2"),"Test1")
     end_match(match_wrestler_vs("Test1","Test3"),"Test1")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishNonTiebreakerMatches
+  test "Pool order three way tie with most team points" do
-    @tournament.matches.where("w1 = ? OR w2 = ? AND w1 != ? OR w2 != ? AND w1 != ? OR w2 != ?",translate_name_to_id("Test1"),translate_name_to_id("Test1"),translate_name_to_id("Test2"),translate_name_to_id("Test2"),translate_name_to_id("Test3"),translate_name_to_id("Test3")).each do | match |
+  	end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
-    	end_match(match,"Test1")
+    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    end
+    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
-    @tournament.matches.where("w1 = ? OR w2 = ? AND w1 != ? OR w2 != ? AND w1 != ? OR w2 != ?",translate_name_to_id("Test2"),translate_name_to_id("Test2"),translate_name_to_id("Test1"),translate_name_to_id("Test1"),translate_name_to_id("Test3"),translate_name_to_id("Test3")).each do | match |
+    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
-    	end_match(match,"Test1")
+    
-    end
+    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
-    @tournament.matches.where("w1 = ? OR w2 = ? AND w1 != ? OR w2 != ? AND w1 != ? OR w2 != ?",translate_name_to_id("Test3"),translate_name_to_id("Test3"),translate_name_to_id("Test1"),translate_name_to_id("Test1"),translate_name_to_id("Test2"),translate_name_to_id("Test2")).each do | match |
+    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
-    	end_match(match,"Test1")
+    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
-    end
+    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
-    @tournament.matches.where("w1 = ? OR w2 = ? AND finished != 1",translate_name_to_id("Test4"),translate_name_to_id("Test4")).each do | match |
-    	end_match(match,"Test4")
-    end
-    @tournament.matches.where("w1 = ? OR w2 = ? AND finished != 1",translate_name_to_id("Test5"),translate_name_to_id("Test5")).each do | match |
-    	end_match(match,"Test5")
-    end
-    @tournament.matches.where("w1 = ? OR w2 = ? AND finished != 1",translate_name_to_id("Test6"),translate_name_to_id("Test6")).each do | match |
-    	end_match(match,"Test6")
-    end
-  end
     
-  def finishWithTieMostTeamPoints
-    end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
     end_match(match_wrestler_vs("Test1","Test3"),"Test3")
-    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
-    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Team Points"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishWithTieMostTeamPointsSecondPlace
+  test "Pool order three way tie with most team points where first place won by wins" do
     end_match(match_wrestler_vs("Test1","Test2"),"Test1")
     end_match(match_wrestler_vs("Test1","Test3"),"Test1")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match_with_pin(match_wrestler_vs("Test2","Test3"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test4"),"Test4")
     end_match(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
+    end_match(match_wrestler_vs("Test2","Test4"),"Test4")
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")  
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Team Points"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishWithTieMostTeamPointsTwoWayTie
+  test "Pool order three way tie with most team points but most team points are tied between two wrestlers" do
     end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Team Points"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 3
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithTieMostFalls
+  test "Pool order three way tie with most pins" do
-    #Test1 has 12 points
+  	#Test1 has 12 points
     #Test2 has 12 points
     #Test3 has 12 points
 
     end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match_with_major(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match_with_pin(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match_with_major(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match_with_major(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Most Pins"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Team Points"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithTieMostTechFalls
+  test "Pool order three way tie with most tech falls" do
-    #Test1 has 11 points
+  	#Test1 has 11 points
     #Test2 has 11 points
     #Test3 has 11 points
 
     end_match_with_tech(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match_with_tech(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match_with_major(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match_with_major(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Most Techs"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Team Points"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithTieQuickestPin
+  test "Pool order three way tie with quickest pin times" do
-    #Test1 has 5:20 of pin time
+    # end_match_with_pin 5:00
-    #Test2 has 9:20 of pin time
+    # end_match_with_quick_pin 1:20
-    #Test3 has 20 minutes of pin time
+    # end_match_with_quickest_pin 0:20
+    
+  	# Test1 has 9:00 of pin time
+    # Test2 has 12:40 of pin time
+    # Test3 has 20:00 of pin time
 
     end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match_with_pin(match_wrestler_vs("Test2","Test3"),"Test2")
-    end_match_with_quick_pin(match_wrestler_vs("Test2","Test4"),"Test2")
+    end_match_with_pin(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match_with_quick_pin(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match_with_quick_pin(match_wrestler_vs("Test2","Test6"),"Test2")
-    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
+    
+    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
+    end_match_with_pin(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match_with_pin(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match_with_pin(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
     end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Pin Time"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Decision Points Scored"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithTieQuickestPinTwoWayTie
+  test "Pool order three way tie with quickest pin times but pin time accumulation is tied between two wrestlers" do
-    #Test1 has 5:20 of pin time
+    # end_match_with_pin 5:00
-    #Test2 has 9:20 of pin time
+    # end_match_with_quick_pin 1:20
-    #Test3 has 5:20 of pin time
+    # end_match_with_quickest_pin 0:20
+    
+  	# Test1 has 9:00 of pin time
+    # Test2 has 9:00 of pin time
+    # Test3 has 12:40 of pin time
 
     end_match_with_pin(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match_with_quick_pin(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match_with_pin(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match_with_quick_pin(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match_with_quick_pin(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match_with_quick_pin(match_wrestler_vs("Test2","Test6"),"Test2")
-    end_match_with_quick_pin(match_wrestler_vs("Test3","Test4"),"Test3")
+    
+    end_match_with_pin(match_wrestler_vs("Test1","Test3"),"Test3")
+    end_match_with_pin(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match_with_quick_pin(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match_with_quick_pin(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Pin Time"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Decision Points Scored"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithTieCoinFlip
+  test "Pool order three way tie with deducted points" do
-    end_match(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
-    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
-    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
-    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
-    end_match(match_wrestler_vs("Test3","Test5"),"Test3")
-    end_match(match_wrestler_vs("Test3","Test6"),"Test3")
-    end_match(match_wrestler_vs("Test4","Test5"),"Test4")
-    end_match(match_wrestler_vs("Test4","Test6"),"Test4")
-    end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
-  end
-
-  def finishedWithDeductedPoints
     team_point_adjusts_for_wrestler("Test2", 1)
     team_point_adjusts_for_wrestler("Test3", 2)
 
     end_match(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
     end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Least Deducted Points"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Least Deducted Points"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
-  def finishedWithDeductedPointsTwoWayTie
+  test "Pool order three way tie with deducted points but least deducted is tied between two wrestlers" do
     team_point_adjusts_for_wrestler("Test1", 2)
     team_point_adjusts_for_wrestler("Test2", 1)
     team_point_adjusts_for_wrestler("Test3", 1)
 
     end_match(match_wrestler_vs("Test1","Test2"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
     end_match(match_wrestler_vs("Test1","Test4"),"Test1")
     end_match(match_wrestler_vs("Test1","Test5"),"Test1")
     end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
     end_match(match_wrestler_vs("Test2","Test3"),"Test2")
     end_match(match_wrestler_vs("Test2","Test4"),"Test2")
     end_match(match_wrestler_vs("Test2","Test5"),"Test2")
     end_match(match_wrestler_vs("Test2","Test6"),"Test2")
-    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
-    end_match(match_wrestler_vs("Test3","Test5"),"Test3")
-    end_match(match_wrestler_vs("Test3","Test6"),"Test3")
-    end_match(match_wrestler_vs("Test4","Test5"),"Test4")
-    end_match(match_wrestler_vs("Test4","Test6"),"Test4")
-    end_match(match_wrestler_vs("Test5","Test6"),"Test5") 
-  end
     
-  def finishedWithDeductedPointsTwoWayTieWithZero
-    team_point_adjusts_for_wrestler("Test1", 1)
-
-    end_match(match_wrestler_vs("Test1","Test2"),"Test1")
     end_match(match_wrestler_vs("Test1","Test3"),"Test3")
-    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
-    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
-    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
-    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
     end_match(match_wrestler_vs("Test3","Test4"),"Test3")
     end_match(match_wrestler_vs("Test3","Test5"),"Test3")
     end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
     end_match(match_wrestler_vs("Test4","Test5"),"Test4")
     end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
     end_match(match_wrestler_vs("Test5","Test6"),"Test5")
-  end
     
-  test "Pool order based on wins" do
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 3
-  	finishWithNoTies
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == nil
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 1
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 2
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Least Deducted Points"
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
-  end
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
-
-  test "Pool order three way tie with most team points" do
-  	finishWithTieMostTeamPoints
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Team Points"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with most team points where first place won by wins" do
-    finishWithTieMostTeamPointsSecondPlace
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Team Points"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with most team points but most team points are tied between two wrestlers" do
-    finishWithTieMostTeamPointsTwoWayTie
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Team Points"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with most pins" do
-  	finishWithTieMostTeamPoints
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Most Pins"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with most tech falls" do
-  	finishWithTieMostTeamPoints
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Most Techs"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with quickest pin times" do
-  	finishedWithTieQuickestPin
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Pin Time"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-   test "Pool order three way tie with quickest pin times but pin time accumulation is tied between two wrestlers" do
-    finishedWithTieQuickestPinTwoWayTie
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Pin Time"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with deducted points" do
-    finishedWithDeductedPoints
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Least Deducted Points"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
-  end
-
-  test "Pool order three way tie with deducted points but least deducted is tied between two wrestlers" do
-    finishedWithDeductedPointsTwoWayTie
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 3
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = ""
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Least Deducted Points"
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 1
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = "Head to Head"
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
   end
 
   test "Pool order three way tie with deducted points but least deducted is tied between two wrestlers with zero" do
-    finishedWithDeductedPointsTwoWayTieWithZero
+    team_point_adjusts_for_wrestler("Test1", 1)
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement = 3
+
-    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker = ""
+    end_match(match_wrestler_vs("Test1","Test2"),"Test1")
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement = 2
+    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker = "Least Deducted Points"
+    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement = 1
+    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
-    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker = "Head to Head"
+    
-    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement = 4
+    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
-    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement = 5
+    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
-    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement = 6
+    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test5"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
+    end_match(match_wrestler_vs("Test4","Test5"),"Test4")
+    end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
+    end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == nil
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Least Deducted Points"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+    assert Wrestler.find(translate_name_to_id("Test5")).pool_placement == 5
+    assert Wrestler.find(translate_name_to_id("Test6")).pool_placement == 6
   end
 
   test "Pool order three way tie with coin flip" do
-  	finishedWithTieCoinFlip
+  	end_match(match_wrestler_vs("Test1","Test2"),"Test1")
-    assert Wrestler.where("weight_id = ? AND pool_placement = 1",@weight.id).first.pool_placement_tiebreaker = "Coin Flip"
+    end_match(match_wrestler_vs("Test1","Test4"),"Test1")
-    assert Wrestler.where("weight_id = ? AND pool_placement = 2",@weight.id).first.pool_placement_tiebreaker = "Head to Head"
+    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
+    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
+    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match(match_wrestler_vs("Test1","Test3"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test5"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
+    end_match(match_wrestler_vs("Test4","Test5"),"Test4")
+    end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
+    end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.where("weight_id = ? AND pool_placement = 1",@weight.id).first.pool_placement_tiebreaker == "Coin Flip"
+    assert Wrestler.where("weight_id = ? AND pool_placement = 2",@weight.id).first.pool_placement_tiebreaker == "Head to Head"
+  end
+  
+  test "Pool order when two two way ties head to head tiebreakers" do
+    end_match(match_wrestler_vs("Test1","Test2"),"Test1")
+    end_match(match_wrestler_vs("Test1","Test3"),"Test1")
+    end_match(match_wrestler_vs("Test1","Test5"),"Test1")
+    end_match(match_wrestler_vs("Test1","Test6"),"Test1")
+    
+    end_match(match_wrestler_vs("Test2","Test3"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test4"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test5"),"Test2")
+    end_match(match_wrestler_vs("Test2","Test6"),"Test2")
+    
+    end_match(match_wrestler_vs("Test3","Test4"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test5"),"Test3")
+    end_match(match_wrestler_vs("Test3","Test6"),"Test3")
+    
+    end_match(match_wrestler_vs("Test1","Test4"),"Test4")
+    end_match(match_wrestler_vs("Test4","Test5"),"Test4")
+    end_match(match_wrestler_vs("Test4","Test6"),"Test4")
+    
+    end_match(match_wrestler_vs("Test5","Test6"),"Test5")
+    
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 4
+  end
+  
+  test "Pool order with 4 wrestlers and two two way ties" do
+    # Setup
+    Wrestler.find(translate_name_to_id("Test5")).destroy
+    Wrestler.find(translate_name_to_id("Test6")).destroy
+    GenerateTournamentMatches.new(Wrestler.find(translate_name_to_id("Test1")).tournament).generate
+    weight = Wrestler.find(translate_name_to_id("Test1")).weight
+    
+    # Match results
+    # Test1 is the best wrestler but got injured after round 1 and forfeited out
+    end_match_custom(match_wrestler_vs("Test3","Test4"),"Tech Fall","0-16","Test3")
+    end_match_custom(match_wrestler_vs("Test2","Test3"),"Pin","0:35","Test3")
+    
+    end_match_custom(match_wrestler_vs("Test2","Test4"),"Pin","1:13","Test4")
+    end_match_custom(match_wrestler_vs("Test4","Test1"),"Forfeit","","Test4")
+    
+    end_match_custom(match_wrestler_vs("Test2","Test1"),"Forfeit","","Test2")
+    
+    end_match_custom(match_wrestler_vs("Test1","Test3"),"Pin","0:44","Test1")
+    
+
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement == 1
+    assert Wrestler.find(translate_name_to_id("Test3")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test4")).pool_placement == 2
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement == 3
+    assert Wrestler.find(translate_name_to_id("Test2")).pool_placement_tiebreaker == "Head to Head"
+    assert Wrestler.find(translate_name_to_id("Test1")).pool_placement == 4
   end
 end

test/test_helper.rb

@@ -172,7 +172,7 @@ class ActiveSupport::TestCase
   def team_point_adjusts_for_wrestler(wrestler_name,points)
     adjust = Teampointadjust.new
     adjust.points = points
-    adjust.wrestler_id = get_wrestler_by_name(wrestler_name)
+    adjust.wrestler_id = get_wrestler_by_name(wrestler_name).id
     adjust.save
   end
 
@@ -201,19 +201,19 @@ class ActiveSupport::TestCase
   
   def end_match_extra_points(match,winner)
      match.win_type = "Decision"
-     match.score = 0-2
+     match.score = "0-2"
      save_match(match,winner)
   end
   
   def end_match_with_major(match,winner)
      match.win_type = "Major"
-     match.score = 8-0
+     match.score = "8-0"
      save_match(match,winner)
   end
   
   def end_match_with_tech(match,winner)
      match.win_type = "Tech Fall"
-     match.score = 15-0
+     match.score = "15-0"
      save_match(match,winner)
   end
   
@@ -235,6 +235,12 @@ class ActiveSupport::TestCase
      save_match(match,winner)
   end
   
+  def end_match_custom(match,win_type,score,winner)
+     match.win_type = win_type
+     match.score = score
+     save_match(match,winner)
+  end
+  
   def save_match(match,winner)
     match.finished = 1
     match.winner_id = translate_name_to_id(winner)