dds-bridge-sys 3.0.0

Generated bindings to DDS, the double dummy solver for bridge
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

"""Tests for par wrapper."""

import unittest
from unittest import SkipTest

from dds3 import par, calc_dd_table
from test_utils import assert_raises


class TestPar(unittest.TestCase):
    """Tests for par (par score calculation)."""

    def test_par_basic(self) -> None:
        """Test basic par calculation with a simple DD table."""
        # First, create a DD table result
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        
        # Note: We can't easily test par without a valid DD table
        # This test demonstrates the API but may not produce meaningful results
        try:
            dd_table = calc_dd_table(table_deal)
            result = par(dd_table)
            self.assertTrue(isinstance(result, dict))
        except RuntimeError:
            # Invalid table is acceptable
            raise SkipTest("Could not create valid DD table")

    def test_par_vulnerable_none(self) -> None:
        """Test par with vulnerable=0 (neither vulnerable)."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
            result = par(dd_table, vulnerable=0)
            self.assertTrue(isinstance(result, dict))
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")

    def test_par_vulnerable_ns(self) -> None:
        """Test par with vulnerable=2 (NS vulnerable)."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
            result = par(dd_table, vulnerable=2)
            self.assertTrue(isinstance(result, dict))
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")

    def test_par_vulnerable_ew(self) -> None:
        """Test par with vulnerable=3 (EW vulnerable)."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
            result = par(dd_table, vulnerable=3)
            self.assertTrue(isinstance(result, dict))
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")

    def test_par_invalid_vulnerable(self) -> None:
        """Test that invalid vulnerable parameter."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")

        assert_raises(ValueError, par, dd_table, vulnerable=4, match="vulnerable has invalid value")

    def test_par_result_structure(self) -> None:
        """Test that par result has expected structure."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
            result = par(dd_table)
            
            self.assertTrue(isinstance(result, dict))
            # Should have par score and contracts
            self.assertTrue("par_score" in result or "par_contracts_string" in result)
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")

    def test_par_requires_table_input(self) -> None:
        """Test that par requires a valid table input."""
        assert_raises((KeyError, ValueError, RuntimeError, TypeError), par, {"invalid": "structure"})

    def test_par_default_vulnerable_is_zero(self) -> None:
        """Test that default vulnerable is 0 (none)."""
        table_deal = {
            "cards": [
                [0x7FFC, 0, 0, 0],
                [0, 0x7FFC, 0, 0],
                [0, 0, 0x7FFC, 0],
                [0, 0, 0, 0x7FFC],
            ],
        }
        try:
            dd_table = calc_dd_table(table_deal)
            # Should not raise when vulnerable is omitted
            result = par(dd_table)
            self.assertTrue(isinstance(result, dict))
        except RuntimeError:
            raise SkipTest("Could not create valid DD table")


if __name__ == "__main__":
    unittest.main()