bridge 0.1.4 → 0.2.0

data/test/test_deal.rb

@@ -1,225 +0,0 @@
-require "helper"
-
-class TestDeal < Test::Unit::TestCase
-  test "first deal conversion" do
-    id = 0
-    deal = Bridge::Deal.from_id(id)
-    assert deal.valid?
-    assert_equal %w(SA SK SQ SJ ST S9 S8 S7 S6 S5 S4 S3 S2).map { |c| Bridge::Card.new(c) }, deal.n
-    assert_equal %w(HA HK HQ HJ HT H9 H8 H7 H6 H5 H4 H3 H2).map { |c| Bridge::Card.new(c) }, deal.e
-    assert_equal %w(DA DK DQ DJ DT D9 D8 D7 D6 D5 D4 D3 D2).map { |c| Bridge::Card.new(c) }, deal.s
-    assert_equal %w(CA CK CQ CJ CT C9 C8 C7 C6 C5 C4 C3 C2).map { |c| Bridge::Card.new(c) }, deal.w
-    assert_equal id, deal.id
-  end
-
-  test "first deal hcp" do
-    deal = Bridge::Deal.from_id(0)
-    assert_equal 10, deal.hcp("N")
-    assert_equal 10, deal.hcp("E")
-    assert_equal 10, deal.hcp("S")
-    assert_equal 10, deal.hcp("W")
-    assert_equal 20, deal.hcp("NS")
-    assert_equal 20, deal.hcp("EW")
-  end
-
-  test "last deal conversion" do
-    id = Bridge::DEALS - 1
-    deal = Bridge::Deal.from_id(id)
-    assert deal.valid?
-    assert_equal %w(CA CK CQ CJ CT C9 C8 C7 C6 C5 C4 C3 C2).map { |c| Bridge::Card.new(c) }, deal.n
-    assert_equal %w(DA DK DQ DJ DT D9 D8 D7 D6 D5 D4 D3 D2).map { |c| Bridge::Card.new(c) }, deal.e
-    assert_equal %w(HA HK HQ HJ HT H9 H8 H7 H6 H5 H4 H3 H2).map { |c| Bridge::Card.new(c) }, deal.s
-    assert_equal %w(SA SK SQ SJ ST S9 S8 S7 S6 S5 S4 S3 S2).map { |c| Bridge::Card.new(c) }, deal.w
-    assert_equal id, deal.id
-  end
-
-  test "last deal hcp" do
-    deal = Bridge::Deal.from_id(Bridge::DEALS - 1)
-    assert_equal 10, deal.hcp("N")
-    assert_equal 10, deal.hcp("E")
-    assert_equal 10, deal.hcp("S")
-    assert_equal 10, deal.hcp("W")
-    assert_equal 20, deal.hcp("NS")
-    assert_equal 20, deal.hcp("EW")
-  end
-
-  test "deal no 1 000 000 000 000" do
-    id = 1_000_000_000_000
-    deal = Bridge::Deal.from_id(id)
-    assert deal.valid?
-    assert_equal id, deal.id
-  end
-
-  test "sample deal to id conversion" do
-    deal = Bridge::Deal.new("N" => %w(SA SK SQ SJ HA HK HQ DA DK DQ CA CK CQ),
-                            "E" => %w(ST S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
-                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
-                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
-    assert deal.valid?
-    id = deal.id
-    assert_equal deal, Bridge::Deal.from_id(id)
-  end
-
-  test "deal with doubled cards is not valid deal" do
-    deal = Bridge::Deal.new("N" => %w(SA SA SQ SJ HA HK HQ DA DK DQ CA CK CQ),
-                            "E" => %w(ST S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
-                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
-                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
-    assert_false deal.valid?
-  end
-
-  test "deal with different length hands is not valid deal" do
-    deal = Bridge::Deal.new("N" => %w(SA SK SQ SJ HA HK HQ DA DK DQ CA CK CQ ST),
-                            "E" => %w(S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
-                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
-                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
-    assert_false deal.valid?
-  end
-
-  test "random deal id is valid deal id" do
-    id = Bridge::Deal.random_id
-    assert Bridge.deal_id?(id)
-  end
-
-  test "random deal is valid deal" do
-    deal = Bridge::Deal.random
-    assert deal.valid?
-  end
-
-  test "comparison of two deals" do
-    deal1 = Bridge::Deal.from_id(1_000_000_000_000_000)
-    deal2 = Bridge::Deal.from_id(9_000_000_000_000_000)
-    assert deal1 < deal2
-  end
-
-  test "fetching wrong direction raises an error" do
-    deal = Bridge::Deal.random
-    assert_raises(ArgumentError) do
-      deal[:h]
-    end
-  end
-
-  test "passing incorrect id to from_id raises an error" do
-    assert_raises(ArgumentError) do
-      Bridge::Deal.from_id(-1)
-    end
-  end
-
-  test "owner returns correct direction" do
-    deal = Bridge::Deal.new({ "N" => ["SK", "S9", "S7", "S6", "S4", "S2", "HA", "HJ", "H2", "D7", "D2", "C6", "C3"],
-                              "E" => ["SA", "SJ", "ST", "H3", "DA", "DK", "DT", "D9", "D8", "D5", "D4", "CK", "CJ"],
-                              "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "DQ", "D3", "CQ", "C4", "C2"],
-                              "W" => ["SQ", "H9", "H7", "H6", "H5", "DJ", "D6", "CA", "CT", "C9", "C8", "C7", "C5"] })
-
-    assert_equal "N", deal.owner("SK")
-    assert_equal "N", deal.owner("C3")
-    assert_equal "E", deal.owner("SJ")
-    assert_equal "E", deal.owner("CK")
-    assert_equal "S", deal.owner("S3")
-    assert_equal "S", deal.owner("CQ")
-    assert_equal "W", deal.owner("H6")
-    assert_equal "W", deal.owner("C9")
-  end
-
-  test "to_hash returns hash" do
-    deal = Bridge::Deal.from_id(0)
-    assert_equal Hash, deal.to_hash.class
-  end
-
-  test "to_hash returns hash with arrays of strings" do
-    deal = Bridge::Deal.from_id(0)
-    assert_equal String, deal.to_hash["N"].first.class
-  end
-end
-
-class TestDealSort < Test::Unit::TestCase
-  def setup
-    @deal = Bridge::Deal.new({ "N" => ["SK", "S9", "S7", "S6", "S4", "HA", "HJ", "H3", "H2", "D7", "D2", "C6", "C3"],
-                              "E" => ["SA", "SQ", "SJ", "ST", "S2", "DA", "DK", "DT", "D9", "D8", "D5", "CK", "CJ"],
-                              "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "DQ", "D3", "CQ", "C4", "C2"],
-                              "W" => ["H9", "H7", "H6", "H5", "DJ", "D6", "D4", "CA", "CT", "C9", "C8", "C7", "C5"] })
-  end
-
-  test "split cards by color for given direction" do
-    expected = { "S" => @deal.n.select { |c| c.suit == "S" },
-                 "H" => @deal.n.select { |c| c.suit == "H" },
-                 "D" => @deal.n.select { |c| c.suit == "D" },
-                 "C" => @deal.n.select { |c| c.suit == "C" } }
-    assert_equal expected, @deal.cards_for("N")
-  end
-
-  test "return colors as key only if cards are present on hand" do
-    expected = { "S" => @deal.e.select { |c| c.suit == "S" },
-                 "H" => [],
-                 "D" => @deal.e.select { |c| c.suit == "D" },
-                 "C" => @deal.e.select { |c| c.suit == "C" } }
-    assert_equal expected, @deal.cards_for("E")
-  end
-
-  test "return sorted 4 colors" do
-    assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["S", "H", "D", "C"])
-    assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["H", "D", "S", "C"])
-    assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["D", "S", "C", "H"])
-  end
-
-  test "return sorted 3 colors" do
-    assert_equal ["S", "H", "C"], @deal.send(:sort_colors, ["S", "H", "C"])
-    assert_equal ["H", "C", "D"], @deal.send(:sort_colors, ["H", "D", "C"])
-    assert_equal ["H", "S", "D"], @deal.send(:sort_colors, ["S", "H", "D"])
-    assert_equal ["S", "D", "C"], @deal.send(:sort_colors, ["S", "D", "C"])
-  end
-
-  test "return sorted 2 colors" do
-    assert_equal ["S", "H"], @deal.send(:sort_colors, ["S", "H"])
-    assert_equal ["S", "D"], @deal.send(:sort_colors, ["S", "D"])
-    assert_equal ["C", "D"], @deal.send(:sort_colors, ["D", "C"])
-    # assert_equal ["H", "C"], @deal.sort_colors(["H", "C"])
-  end
-
-  test "return sorted 4 colors with trump" do
-    assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["S", "H", "D", "C"], "S")
-    assert_equal ["H", "S", "D", "C"], @deal.send(:sort_colors, ["H", "D", "S", "C"], "H")
-    assert_equal ["D", "S", "H", "C"], @deal.send(:sort_colors, ["D", "S", "C", "H"], "D")
-    assert_equal ["C", "H", "S", "D"], @deal.send(:sort_colors, ["D", "S", "C", "H"], "C")
-  end
-
-  test "return sorted 3 colors with trump" do
-    assert_equal ["S", "H", "C"], @deal.send(:sort_colors, ["S", "H", "C"], "S")
-    assert_equal ["H", "S", "C"], @deal.send(:sort_colors, ["S", "H", "C"], "H")
-    assert_equal ["S", "H", "D"], @deal.send(:sort_colors, ["S", "H", "D"], "S")
-    assert_equal ["D", "S", "H"], @deal.send(:sort_colors, ["S", "H", "D"], "D")
-  end
-
-  test "return sorted 2 colors with trump" do
-    assert_equal ["S", "H"], @deal.send(:sort_colors, ["S", "H"], "S")
-    assert_equal ["H", "S"], @deal.send(:sort_colors, ["S", "H"], "H")
-    assert_equal ["C", "S"], @deal.send(:sort_colors, ["S", "C"], "C")
-    assert_equal ["D", "H"], @deal.send(:sort_colors, ["H", "D"], "D")
-  end
-
-  test "sort hands by colors" do
-    expected =  {
-      "N" => ["SK", "S9", "S7", "S6", "S4", "HA", "HJ", "H3", "H2", "C6", "C3", "D7", "D2"],
-      "E" => ["SA", "SQ", "SJ", "ST", "S2", "DA", "DK", "DT", "D9", "D8", "D5", "CK", "CJ"],
-      "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "CQ", "C4", "C2", "DQ", "D3"],
-      "W" => ["H9", "H7", "H6", "H5", "CA", "CT", "C9", "C8", "C7", "C5", "DJ", "D6", "D4"]
-    }
-    assert_equal expected, @deal.sort_by_color!.to_hash
-  end
-
-  test "sort hands by colors with trump" do
-    expected = {
-      "N" => ["C6", "C3", "HA", "HJ", "H3", "H2", "SK", "S9", "S7", "S6", "S4", "D7", "D2"],
-      "E" => ["CK", "CJ", "DA", "DK", "DT", "D9", "D8", "D5", "SA", "SQ", "SJ", "ST", "S2"],
-      "S" => ["CQ", "C4", "C2", "HK", "HQ", "HT", "H8", "H4", "S8", "S5", "S3", "DQ", "D3"],
-      "W" => ["CA", "CT", "C9", "C8", "C7", "C5", "H9", "H7", "H6", "H5", "DJ", "D6", "D4"]
-    }
-    assert_equal expected, @deal.sort_by_color!("C").to_hash
-  end
-
-  test "not modify hands if sorted by color without !" do
-    old_deal = @deal.to_hash
-    @deal.sort_by_color
-    assert_equal old_deal, @deal.to_hash
-  end
-end

data/test/test_score.rb

@@ -1,330 +0,0 @@
-require "helper"
-
-class TestScore < Test::Unit::TestCase
-
-  def setup
-    @score = Bridge::Score.new(:contract => "1S", :vulnerable => false, :tricks => 9)
-  end
-
-  test "valid score" do
-    assert_false @score.contract.nil?
-    assert_false @score.vulnerable.nil?
-    assert_false @score.tricks.nil?
-  end
-
-  test "default vulnerable set to false" do
-    score = Bridge::Score.new(:contract => "1S", :tricks => 9)
-    assert_equal false, score.vulnerable
-  end
-
-  test "return modifier and contract when doubled" do
-    score = Bridge::Score.new(:contract => "4SX", :tricks => 9)
-    assert_equal 2, score.instance_variable_get(:@modifier)
-    assert_equal "4S", score.contract.to_s
-  end
-
-  test "return modifier and contract when redoubled" do
-    score = Bridge::Score.new(:contract => "4SXX", :tricks => 9)
-    assert_equal 4, score.instance_variable_get(:@modifier)
-    assert_equal "4S", score.contract.to_s
-  end
-
-  test "return tricks to make contract" do
-    assert_equal 7, @score.tricks_to_make_contract
-    score = Bridge::Score.new(:contract => "6S", :tricks => 9)
-    assert_equal 12, score.tricks_to_make_contract
-  end
-
-  test "return made contract?" do
-    score = Bridge::Score.new(:contract => "6S", :tricks => 9)
-    assert_false score.made?
-    score = Bridge::Score.new(:contract => "3NT", :tricks => 3)
-    assert_false score.made?
-    score = Bridge::Score.new(:contract => "7NT", :tricks => 13)
-    assert score.made?
-    score = Bridge::Score.new(:contract => "3NT", :tricks => 11)
-    assert score.made?
-  end
-
-  test "return result" do
-    assert_equal 2, @score.result
-    score = Bridge::Score.new(:contract => "6S", :tricks => 12)
-    assert_equal 0, score.result
-    score = Bridge::Score.new(:contract => "6S", :tricks => 10)
-    assert_equal -2, score.result
-  end
-
-  test "return result string" do
-    assert_equal "+2", @score.result_string
-    score = Bridge::Score.new(:contract => "6S", :tricks => 12)
-    assert_equal "=", score.result_string
-    score = Bridge::Score.new(:contract => "6S", :tricks => 10)
-    assert_equal "-2", score.result_string
-  end
-
-  test "return vulnerable" do
-    assert_false @score.vulnerable?
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => true, :tricks => 12)
-    assert score.vulnerable?
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => false, :tricks => 10)
-    assert_false score.vulnerable?
-  end
-
-  test "calculate tricks with plus" do
-    score = Bridge::Score.new(:contract => "4S", :tricks => "+1")
-    assert_equal 11, score.tricks
-  end
-
-  test "calculate tricks with minus" do
-    score = Bridge::Score.new(:contract => "4S", :tricks => "-4")
-    assert_equal 6, score.tricks
-  end
-
-  test "calculate tricks with equal sign" do
-    score = Bridge::Score.new(:contract => "4S", :tricks => "=")
-    assert_equal 10, score.tricks
-  end
-
-  test "15 is not a valid tricks argument" do
-    assert_raises(ArgumentError) do
-      Bridge::Score.new(:contract => "4S", :tricks => 15)
-    end
-  end
-
-  test "wrong string is not a valid tricks argument" do
-    assert_raises(ArgumentError) do
-      Bridge::Score.new(:contract => "4S", :tricks => "wrong")
-    end
-  end
-end
-
-class TestScorePoints < Test::Unit::TestCase
-
-  test "game bonus" do
-    score = Bridge::Score.new(:contract => "3S", :vulnerable => false, :tricks => 9)
-    assert_equal 50, score.game_bonus
-    score = Bridge::Score.new(:contract => "4S", :vulnerable => false, :tricks => 10)
-    assert_equal 300, score.game_bonus
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => false, :tricks => 12)
-    assert_equal 300, score.game_bonus
-    score = Bridge::Score.new(:contract => "3NT", :vulnerable => true, :tricks => 9)
-    assert_equal 500, score.game_bonus
-    score = Bridge::Score.new(:contract => "3NT", :vulnerable => true, :tricks => 3)
-    assert_equal 0, score.game_bonus
-    score = Bridge::Score.new(:contract => "3SX", :vulnerable => true, :tricks => 9)
-    assert_equal 500, score.game_bonus
-  end
-
-  test "small slam bonus" do
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => false, :tricks => 12)
-    assert_equal 500, score.small_slam_bonus
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => true, :tricks => 12)
-    assert_equal 750, score.small_slam_bonus
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => true, :tricks => 10)
-    assert_equal 0, score.small_slam_bonus
-  end
-
-  test "grand slam bonus" do
-    score = Bridge::Score.new(:contract => "7S", :vulnerable => false, :tricks => 13)
-    assert_equal 1000, score.grand_slam_bonus
-    score = Bridge::Score.new(:contract => "7S", :vulnerable => true, :tricks => 13)
-    assert_equal 1500, score.grand_slam_bonus
-    score = Bridge::Score.new(:contract => "7S", :vulnerable => true, :tricks => 11)
-    assert_equal 0, score.grand_slam_bonus
-    score = Bridge::Score.new(:contract => "6S", :vulnerable => true, :tricks => 13)
-    assert_equal 0, score.grand_slam_bonus
-  end
-
-  test "doubled and redoubled cotract made bonus" do
-    score = Bridge::Score.new(:contract => "4SX", :tricks => 10)
-    assert_equal 50, score.doubled_bonus
-    score = Bridge::Score.new(:contract => "4SXX", :tricks => 10)
-    assert_equal 100, score.redoubled_bonus
-    assert_equal 0, score.doubled_bonus
-  end
-
-  test "vulnerable undertrick points" do
-    score = Bridge::Score.new(:contract => "4S", :vulnerable => true, :tricks => 9)
-    assert_equal -100, score.vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SX", :vulnerable => true, :tricks => 9)
-    assert_equal -200, score.vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SX", :vulnerable => true, :tricks => 7)
-    assert_equal -800, score.vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SXX", :vulnerable => true, :tricks => 9)
-    assert_equal -400, score.vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SXX", :vulnerable => true, :tricks => 7)
-    assert_equal -1600, score.vulnerable_undertrick_points
-  end
-
-  test "not vulnerable undertrick points" do
-    score = Bridge::Score.new(:contract => "4S", :vulnerable => false, :tricks => 9)
-    assert_equal -50, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SX", :vulnerable => false, :tricks => 9)
-    assert_equal -100, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SX", :vulnerable => false, :tricks => 7)
-    assert_equal -500, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SXX", :vulnerable => false, :tricks => 9)
-    assert_equal -200, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SXX", :vulnerable => false, :tricks => 7)
-    assert_equal -1000, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SX", :vulnerable => false, :tricks => 6)
-    assert_equal -800, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4SXX", :vulnerable => false, :tricks => 6)
-    assert_equal -1600, score.not_vulnerable_undertrick_points
-    score = Bridge::Score.new(:contract => "4S", :vulnerable => false, :tricks => 6)
-    assert_equal -200, score.not_vulnerable_undertrick_points
-  end
-
-  test "overtrick points" do
-    score = Bridge::Score.new(:contract => "2S", :vulnerable => false, :tricks => 10)
-    assert_equal 60, score.overtrick_points
-    score = Bridge::Score.new(:contract => "2SX", :vulnerable => false, :tricks => 9)
-    assert_equal 100, score.overtrick_points
-    score = Bridge::Score.new(:contract => "2SXX", :vulnerable => false, :tricks => 9)
-    assert_equal 200, score.overtrick_points
-    score = Bridge::Score.new(:contract => "2S", :vulnerable => true, :tricks => 9)
-    assert_equal 30, score.overtrick_points
-    score = Bridge::Score.new(:contract => "2SX", :vulnerable => true, :tricks => 9)
-    assert_equal 200, score.overtrick_points
-    score = Bridge::Score.new(:contract => "2SXX", :vulnerable => true, :tricks => 9)
-    assert_equal 400, score.overtrick_points
-  end
-
-  test "return 90 points for 1S=" do
-    score = Bridge::Score.new(:contract => "3S", :vulnerable => false, :tricks => 9)
-    assert_equal 140, score.points
-  end
-
-  test "return 70 points for 2S=" do
-    score = Bridge::Score.new(:contract => "2NT", :vulnerable => false, :tricks => 8)
-    assert_equal 120, score.points
-  end
-
-  test "return 80 points for 2D+2" do
-    score = Bridge::Score.new(:contract => "2D", :vulnerable => false, :tricks => 10)
-    assert_equal 130, score.points
-  end
-
-  test "return 1400 points for 5CXX+1" do
-    score = Bridge::Score.new(:contract => "5CXX", :vulnerable => true, :tricks => 12)
-    assert_equal 1400, score.points
-  end
-
-  test "return 1700 points for 3NTX-7" do
-    score = Bridge::Score.new(:contract => "3NTX", :vulnerable => false, :tricks => 2)
-    assert_equal -1700, score.points
-  end
-
-  test "return -7600 points for 7NTXX-13" do
-    score = Bridge::Score.new(:contract => "7NTXX", :vulnerable => true, :tricks => 0)
-    assert_equal -7600, score.points
-  end
-
-  test "return -7600 points for 7NT-13" do
-    score = Bridge::Score.new(:contract => "7NT", :vulnerable => false, :tricks => 0)
-    assert_equal -650, score.points
-  end
-
-  test "return -1300 points for 7NT-13" do
-    score = Bridge::Score.new(:contract => "7NT", :vulnerable => true, :tricks => 0)
-    assert_equal -1300, score.points
-  end
-
-  test "return -3500 points for 7NTX-13" do
-    score = Bridge::Score.new(:contract => "7NTX", :vulnerable => false, :tricks => 0)
-    assert_equal -3500, score.points
-  end
-
-  test "return -3800 points for 7NTX-13" do
-    score = Bridge::Score.new(:contract => "7NTX", :vulnerable => true, :tricks => 0)
-    assert_equal -3800, score.points
-  end
-
-  test "return -7000 points for 7NTXX-13" do
-    score = Bridge::Score.new(:contract => "7NTXX", :vulnerable => false, :tricks => 0)
-    assert_equal -7000, score.points
-  end
-
-  test "return 1340 points for 1CX+6" do
-    score = Bridge::Score.new(:contract => "1CX", :vulnerable => true, :tricks => 13)
-    assert_equal 1340, score.points
-  end
-
-  test "return 740 points for 1CX+6" do
-    score = Bridge::Score.new(:contract => "1CX", :vulnerable => false, :tricks => 13)
-    assert_equal 740, score.points
-  end
-end
-
-class TestScoreContracts < Test::Unit::TestCase
-  test "1764 results" do
-    assert_equal 1764, Bridge::Score.all_contracts.size
-  end
-
-  test "return contracts for 1430 points" do
-    expected = ["1C/DXX+3v", "1C/DXX+6", "6H/S=v"]
-    assert_equal expected, Bridge::Score.with_points(1430)
-  end
-
-  test "return no contracts if not found score with given points" do
-    assert_equal [], Bridge::Score.with_points(100)
-  end
-end
-
-class TestRegexpScore < Test::Unit::TestCase
-  def setup
-    @regexp = Bridge::Score::REGEXP
-  end
-
-  test "match 1S+1" do
-    assert "1S+1" =~ @regexp
-  end
-
-  test "match 1NT=" do
-    assert "1NT=" =~ @regexp
-  end
-
-  test "not match 8S=" do
-    assert_nil "8S=" =~ @regexp
-  end
-
-  test "not match 1SXXX=" do
-    assert_nil "1SXXX=" =~ @regexp
-  end
-
-  test "not match 1S+7" do
-    assert_nil "1S+7" =~ @regexp
-  end
-
-  test "not match 1S-14" do
-    assert_nil "1S-14" =~ @regexp
-  end
-
-  test "not match 1S-21" do
-    assert_nil "1S-21" =~ @regexp
-  end
-
-  test "case sensitive" do
-    assert_nil "1s-1" =~ @regexp
-  end
-
-  test "return contract for 1NT=" do
-    result = "1NT=".match(@regexp)
-    assert_equal "1NT", RUBY_VERSION >= "1.9" ? result[:contract] : result[1]
-  end
-
-  test "return contract for 1NTXX=" do
-    result = "1NTXX=".match(@regexp)
-    assert_equal "1NTXX", RUBY_VERSION >= "1.9" ? result[:contract] : result[1]
-  end
-
-  test "return result for 1NT=" do
-    result = "1NT=".match(@regexp)
-    assert_equal "=", RUBY_VERSION >= "1.9" ? result[:result] : result[5]
-  end
-
-  test "return result for 1NT+2" do
-    result = "1NT+2".match(@regexp)
-    assert_equal "+2", RUBY_VERSION >= "1.9" ? result[:result] : result[5]
-  end
-end