cython

1
# mode: run
2
# tag: cpp, werror, cpp11, no-cpp-locals
3

4
import sys
5
from libcpp.unordered_map cimport unordered_map
6
from libcpp.unordered_set cimport unordered_set
7
from libcpp.vector cimport vector
8
from libcpp.queue cimport queue
9
from libcpp.queue cimport priority_queue
10
from libcpp.vector cimport vector
11
from libcpp.pair cimport pair
12
from libcpp.map cimport map
13
from libcpp.set cimport set
14
from libcpp.deque cimport deque
15
from libcpp.functional cimport reference_wrapper
16

17

18
def test_reference_wrapper():
19
    """
20
    >>> test_reference_wrapper()
21
    'pass'
22
    """
23
    cdef:
24
        int x = 1
25
        vector[reference_wrapper[int]] ref_wrap_vector
26
    ref_wrap_vector.push_back(reference_wrapper[int](x))
27
    assert ref_wrap_vector[0].get() == 1
28
    return "pass"
29

30

31
def test_vector_functionality():
32
    """
33
    >>> test_vector_functionality()
34
    'pass'
35
    """
36
    cdef:
37
        vector[int] int_vector = vector[int]()
38
        int* data
39
        const int* const_data
40
    int_vector.push_back(77)
41
    data = int_vector.data()
42
    const_data = int_vector.const_data()
43
    assert data[0] == 77
44
    assert const_data[0] == 77
45
    return "pass"
46

47

48
def test_queue_functionality():
49
    """
50
    >>> test_queue_functionality()
51
    'pass'
52
    """
53
    cdef:
54
        queue[int] int_queue = queue[int]()
55
        queue[int] int_queue2 = queue[int]()
56
    int_queue.push(77)
57
    int_queue.swap(int_queue2)
58
    assert int_queue.size() == 0
59
    assert int_queue2.size() == 1
60
    return "pass"
61

62

63
def test_deque_functionality():
64
    """
65
    >>> test_deque_functionality()
66
    'pass'
67
    """
68
    cdef:
69
        deque[int] int_deque = deque[int]()
70
    int_deque.push_back(77)
71
    int_deque.shrink_to_fit()
72

73
    int_deque.emplace_front(66)
74
    int_deque.emplace_back(88)
75
    assert int_deque.front() == 66
76
    assert int_deque.back() == 88
77
    return "pass"
78

79

80
def test_priority_queue_functionality():
81
    """
82
    >>> test_priority_queue_functionality()
83
    'pass'
84
    """
85
    cdef:
86
        priority_queue[int] int_queue = priority_queue[int]()
87
        priority_queue[int] int_queue2 = priority_queue[int]()
88
    int_queue.push(77)
89
    int_queue.swap(int_queue2)
90
    assert int_queue.size() == 0
91
    assert int_queue2.size() == 1
92
    return "pass"
93

94

95
def test_set_functionality():
96
    """
97
    >>> test_set_functionality()
98
    'pass'
99
    """
100
    cdef:
101
        set[int] int_set
102
        set[int] int_set2
103
    int_set2.insert(77)
104
    int_set2.insert(66)
105
    int_set.insert(int_set2.const_begin(), int_set2.const_end())
106
    assert int_set.size() == 2
107
    assert int_set.erase(int_set.const_begin(), int_set.const_end()) == int_set.end()
108
    return "pass"
109

110

111
def test_map_functionality():
112
    """
113
    >>> test_map_functionality()
114
    'pass'
115
    """
116
    cdef:
117
        map[int, const void*] int_map
118
        const void* data
119
    int_map[77] = NULL
120
    data = int_map.const_at(77)
121
    return "pass"
122

123

124
def test_unordered_set_functionality():
125
    """
126
    >>> test_unordered_set_functionality()
127
    'pass'
128
    """
129
    cdef:
130
        unordered_set[int] int_set = unordered_set[int]()
131
        unordered_set[int] int_set2
132
        unordered_set[int].iterator iterator = int_set.begin()
133
    int_set.insert(1)
134
    assert int_set.size() == 1
135
    int_set.erase(unordered_set[int].const_iterator(int_set.begin()), unordered_set[int].const_iterator(int_set.end()))
136
    assert int_set.size() == 0
137
    int_set.insert(1)
138
    assert int_set.erase(1) == 1 # returns number of elements erased
139
    assert int_set.size() == 0
140
    int_set.insert(1)
141
    iterator = int_set.find(1)
142
    assert int_set.erase(iterator) == int_set.end()
143

144
    int_set2.insert(3)
145
    int_set2.insert(5)
146
    int_set.insert(int_set2.begin(), int_set2.end())
147
    assert int_set.size() == 2
148

149
    if sys.platform != 'darwin':
150
        int_set.max_load_factor(0.5)
151
        assert int_set.max_load_factor() == 0.5
152
    int_set.rehash(20)
153
    int_set.reserve(20)
154

155
    int_set.bucket_size(0)
156
    int_set.bucket_count()
157
    int_set.max_bucket_count()
158
    int_set.bucket(3)
159
    assert int_set.load_factor() > 0
160
    return "pass"
161

162

163
cdef extern from "cpp_unordered_map_helper.h":
164
    cdef cppclass IntVectorHash:
165
        pass
166

167

168
def test_unordered_map_functionality():
169
    """
170
    >>> test_unordered_map_functionality()
171
    'pass'
172
    """
173
    cdef:
174
        unordered_map[int, int] int_map = unordered_map[int,int]()
175
        pair[int, int] pair_insert = pair[int, int](1, 2)
176
        unordered_map[int,int].iterator iterator = int_map.begin()
177
        pair[unordered_map[int,int].iterator, bint] pair_iter  = int_map.insert(pair_insert)
178
        unordered_map[int, int] int_map2
179
        unordered_map[int, int*] intptr_map
180
        const int* intptr
181
        unordered_map[vector[int], int, IntVectorHash] int_vector_map
182
        vector[int] intvec
183
    assert int_map[1] == 2
184
    assert int_map.size() == 1
185
    assert int_map.erase(1) == 1 # returns number of elements erased
186
    assert int_map.size() == 0
187
    int_map[1] = 2
188
    assert int_map.size() == 1
189
    assert int_map[1] == 2
190
    iterator = int_map.find(1)
191
    assert int_map.erase(iterator) == int_map.end()
192

193
    int_map2[1] = 2
194
    int_map2[3] = 3
195
    int_map.clear()
196
    int_map.insert(int_map2.begin(), int_map2.end())
197
    assert int_map.size() == 2
198
    assert int_map.erase(unordered_map[int,int].const_iterator(int_map.begin()), unordered_map[int,int].const_iterator(int_map.end())) == int_map.end()
199

200
    int_map.max_load_factor(0.5)
201
    assert int_map.max_load_factor() == 0.5
202
    int_map.rehash(20)
203
    int_map.reserve(20)
204

205
    int_map[3] = 3
206
    int_map.bucket_size(0)
207
    int_map.bucket_count()
208
    int_map.max_bucket_count()
209
    int_map.bucket(3)
210
    assert int_map.load_factor() > 0
211

212
    intptr_map[0] = NULL
213
    intptr = intptr_map.const_at(0)
214

215
    intvec = [1, 2]
216
    int_vector_map[intvec] = 3
217
    intvec = [4, 5]
218
    int_vector_map[intvec] = 6
219
    assert int_vector_map[intvec] == 6
220
    intvec = [1, 2]
221
    assert int_vector_map[intvec] == 3
222
    return "pass"
223