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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
import py, os, sys
from .support import setup_make
currpath = py.path.local(__file__).dirpath()
test_dct = str(currpath.join("templatesDict.so"))
def setup_module(mod):
setup_make("templatesDict.so")
class AppTestTEMPLATES:
spaceconfig = dict(usemodules=['_cppyy', '_rawffi', 'itertools'])
def setup_class(cls):
cls.w_test_dct = cls.space.newtext(test_dct)
cls.w_templates = cls.space.appexec([], """():
import ctypes, _cppyy
_cppyy._post_import_startup()
return ctypes.CDLL(%r, ctypes.RTLD_GLOBAL)""" % (test_dct, ))
def test01_template_member_functions(self):
"""Template member functions lookup and calls"""
import _cppyy
m = _cppyy.gbl.MyTemplatedMethodClass()
# pre-instantiated
assert m.get_size['char']() == m.get_char_size()
assert m.get_size[int]() == m.get_int_size()
# specialized
assert m.get_size[long]() == m.get_long_size()
# auto-instantiation
assert m.get_size[float]() == m.get_float_size()
assert m.get_size['double']() == m.get_double_size()
assert m.get_size['MyTemplatedMethodClass']() == m.get_self_size()
# auto through typedef
assert m.get_size['MyTMCTypedef_t']() == m.get_self_size()
def test02_non_type_template_args(self):
"""Use of non-types as template arguments"""
import _cppyy
_cppyy.gbl.gInterpreter.Declare("template<int i> int nt_templ_args() { return i; };")
assert _cppyy.gbl.nt_templ_args[1]() == 1
assert _cppyy.gbl.nt_templ_args[256]() == 256
def test03_templated_function(self):
"""Templated global and static functions lookup and calls"""
import _cppyy as cppyy
# TODO: the following only works if something else has already
# loaded the headers associated with this template
ggs = cppyy.gbl.global_get_size
assert ggs['char']() == 1
gsf = cppyy.gbl.global_some_foo
assert gsf[int](3) == 42
assert gsf(3) == 42
assert gsf(3.) == 42
gsb = cppyy.gbl.global_some_bar
assert gsb(3) == 13
assert gsb['double'](3.) == 13
# TODO: the following only works in a namespace
nsgsb = cppyy.gbl.SomeNS.some_bar
assert nsgsb[3]
assert nsgsb[3]() == 3
# TODO: add some static template method
# test forced creation of subsequent overloads
vector = cppyy.gbl.std.vector
# float in, float out
ggsr = cppyy.gbl.global_get_some_result['std::vector<float>']
assert type(ggsr(vector['float']([0.5])).m_retval) == float
assert ggsr(vector['float']([0.5])).m_retval == 0.5
# int in, float out
ggsr = cppyy.gbl.global_get_some_result['std::vector<int>']
assert type(ggsr(vector['int']([5])).m_retval) == float
assert ggsr(vector['int']([5])).m_retval == 5.
# float in, int out
# TODO: this now matches the earlier overload
#ggsr = cppyy.gbl.global_get_some_result['std::vector<float>, int']
#assert type(ggsr(vector['float']([0.3])).m_retval) == int
#assert ggsr(vector['float']([0.3])).m_retval == 0
# int in, int out
# TODO: same as above, matches earlier overload
#ggsr = cppyy.gbl.global_get_some_result['std::vector<int>, int']
#assert type(ggsr(vector['int']([5])).m_retval) == int
#assert ggsr(vector['int']([5])).m_retval == 5
def test04_variadic_function(self):
"""Call a variadic function"""
import _cppyy
s = _cppyy.gbl.std.ostringstream('(', _cppyy.gbl.std.ios_base.ate)
# Fails; selects void* overload (?!)
#s << "("
_cppyy.gbl.SomeNS.tuplify(s, 1, 4., "aap")
assert s.str() == "(1, 4, aap, NULL)"
_cppyy.gbl.gInterpreter.Declare("""
template<typename... myTypes>
int test04_variadic_func() { return sizeof...(myTypes); }
""")
assert _cppyy.gbl.test04_variadic_func['int', 'double', 'void*']() == 3
def test05_variadic_overload(self):
"""Call an overloaded variadic function"""
import _cppyy
assert _cppyy.gbl.isSomeInt(3.) == False
assert _cppyy.gbl.isSomeInt(1) == True
assert _cppyy.gbl.isSomeInt() == False
assert _cppyy.gbl.isSomeInt(1, 2, 3) == False
def test06_variadic_sfinae(self):
"""Attribute testing through SFINAE"""
import _cppyy
Obj1 = _cppyy.gbl.AttrTesting.Obj1
Obj2 = _cppyy.gbl.AttrTesting.Obj2
has_var1 = _cppyy.gbl.AttrTesting.has_var1
call_has_var1 = _cppyy.gbl.AttrTesting.call_has_var1
move = _cppyy.gbl.std.move
assert has_var1(Obj1()) == hasattr(Obj1(), 'var1')
assert has_var1(Obj2()) == hasattr(Obj2(), 'var1')
assert has_var1(3) == hasattr(3, 'var1')
assert has_var1("aap") == hasattr("aap", 'var1')
assert call_has_var1(move(Obj1())) == True
assert call_has_var1(move(Obj2())) == False
def test07_type_deduction(self):
"""Traits/type deduction"""
import _cppyy
Obj1 = _cppyy.gbl.AttrTesting.Obj1
Obj2 = _cppyy.gbl.AttrTesting.Obj2
select_template_arg = _cppyy.gbl.AttrTesting.select_template_arg
# assert select_template_arg[0, Obj1, Obj2].argument == Obj1
assert select_template_arg[1, Obj1, Obj2].argument == Obj2
raises(TypeError, select_template_arg.__getitem__, 2, Obj1, Obj2)
# TODO, this doesn't work for builtin types as the 'argument'
# typedef will not resolve to a class
#assert select_template_arg[1, int, float].argument == float
def test08_using_of_static_data(self):
"""Derived class using static data of base"""
import _cppyy
# TODO: the following should live in templates.h, but currently fails
# in TClass::GetListOfMethods()
_cppyy.gbl.gInterpreter.Declare("""
template <typename T> struct BaseClassWithStatic {
static T const ref_value;
};
template <typename T>
T const BaseClassWithStatic<T>::ref_value = 42;
template <typename T>
struct DerivedClassUsingStatic : public BaseClassWithStatic<T> {
using BaseClassWithStatic<T>::ref_value;
explicit DerivedClassUsingStatic(T x) : BaseClassWithStatic<T>() {
m_value = x > ref_value ? ref_value : x;
}
T m_value;
};""")
# TODO: the ref_value property is inaccessible (offset == -1)
# assert _cppyy.gbl.BaseClassWithStatic["size_t"].ref_value == 42
b1 = _cppyy.gbl.DerivedClassUsingStatic["size_t"]( 0)
b2 = _cppyy.gbl.DerivedClassUsingStatic["size_t"](100)
# assert b1.ref_value == 42
assert b1.m_value == 0
# assert b2.ref_value == 42
assert b2.m_value == 42
class AppTestBOOSTANY:
spaceconfig = dict(usemodules=['_cppyy', '_rawffi', 'itertools'])
def setup_class(cls):
cls.w_test_dct = cls.space.newtext(test_dct)
cls.w_templates = cls.space.appexec([], """():
import ctypes, _cppyy
_cppyy._post_import_startup()""")
def test01_any_class(self):
"""Usage of boost::any"""
import _cppyy
if not _cppyy.gbl.gInterpreter.Declare('#include "boost/any.hpp"'):
import warnings
warnings.warn('skipping boost/any testing')
return
assert _cppyy.gbl.boost
assert _cppyy.gbl.boost.any
std, boost = _cppyy.gbl.std, _cppyy.gbl.boost
assert std.list[boost.any]
val = boost.any()
# test both by-ref and by rvalue
v = std.vector[int]()
val.__assign__(v)
val.__assign__(std.move(std.vector[int](range(100))))
_cppyy.gbl.gInterpreter.ProcessLine(
"namespace _cppyy_internal { auto* stdvectid = &typeid(std::vector<int>); }")
assert val.type() == _cppyy.gbl._cppyy_internal.stdvectid
extract = boost.any_cast[std.vector[int]](val)
assert type(extract) is std.vector[int]
assert len(extract) == 100
extract += range(100)
assert len(extract) == 200
val.__assign__(std.move(extract)) # move forced
# TODO: we hit boost::any_cast<int>(boost::any* operand) instead
# of the reference version which raises
boost.any_cast.__useffi__ = False
try:
# raises(Exception, boost.any_cast[int], val)
assert not boost.any_cast[int](val)
except Exception:
# getting here is good, too ...
pass
extract = boost.any_cast[std.vector[int]](val)
assert len(extract) == 200
|
