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
|
require_relative 'test_base'
require 'dl/func'
module DL
class TestFunc < TestBase
def test_name
f = Function.new(CFunc.new(@libc['strcpy'], TYPE_VOIDP, 'strcpy'),
[TYPE_VOIDP, TYPE_VOIDP])
assert_equal 'strcpy', f.name
end
def test_name_with_block
begin
cb = Function.new(CFunc.new(0, TYPE_INT, '<callback>qsort'),
[TYPE_VOIDP, TYPE_VOIDP]){|x,y| CPtr.new(x)[0] <=> CPtr.new(y)[0]}
assert_equal('<callback>qsort', cb.name)
ensure
cb.unbind if cb # max number of callbacks is limited to MAX_CALLBACK
end
end
def test_bound
f = Function.new(CFunc.new(0, TYPE_INT, 'test'), [TYPE_INT, TYPE_INT])
assert_equal false, f.bound?
begin
f.bind { |x,y| x + y }
assert_equal true, f.bound?
ensure
f.unbind # max number of callbacks is limited to MAX_CALLBACK
end
end
def test_bound_for_callback_closure
begin
f = Function.new(CFunc.new(0, TYPE_INT, 'test'),
[TYPE_INT, TYPE_INT]) { |x,y| x + y }
assert_equal true, f.bound?
ensure
f.unbind if f # max number of callbacks is limited to MAX_CALLBACK
end
end
def test_unbind
f = Function.new(CFunc.new(0, TYPE_INT, 'test'), [TYPE_INT, TYPE_INT])
begin
f.bind { |x, y| x + y }
assert_nothing_raised { f.unbind }
assert_equal false, f.bound?
# unbind() after unbind() should not raise error
assert_nothing_raised { f.unbind }
ensure
f.unbind # max number of callbacks is limited to MAX_CALLBACK
end
end
def test_unbind_normal_function
f = Function.new(CFunc.new(@libc['strcpy'], TYPE_VOIDP, 'strcpy'),
[TYPE_VOIDP, TYPE_VOIDP])
assert_nothing_raised { f.unbind }
assert_equal false, f.bound?
# unbind() after unbind() should not raise error
assert_nothing_raised { f.unbind }
end
def test_bind
f = Function.new(CFunc.new(0, TYPE_INT, 'test'), [TYPE_INT, TYPE_INT])
begin
assert_nothing_raised {
f.bind { |x, y| x + y }
}
assert_equal 579, f.call(123, 456)
ensure
f.unbind # max number of callbacks is limited to MAX_CALLBACK
end
end
def test_to_i
cfunc = CFunc.new(@libc['strcpy'], TYPE_VOIDP, 'strcpy')
f = Function.new(cfunc, [TYPE_VOIDP, TYPE_VOIDP])
assert_equal cfunc.to_i, f.to_i
end
def test_random
f = Function.new(CFunc.new(@libc['srand'], TYPE_VOID, 'srand'),
[-TYPE_LONG])
assert_nil f.call(10)
end
def test_sinf
return if /x86_64/ =~ RUBY_PLATFORM
begin
f = Function.new(CFunc.new(@libm['sinf'], TYPE_FLOAT, 'sinf'),
[TYPE_FLOAT])
rescue DL::DLError
skip "libm may not have sinf()"
end
assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001
end
def test_sin
return if /x86_64/ =~ RUBY_PLATFORM
f = Function.new(CFunc.new(@libm['sin'], TYPE_DOUBLE, 'sin'),
[TYPE_DOUBLE])
assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001
end
def test_strcpy()
f = Function.new(CFunc.new(@libc['strcpy'], TYPE_VOIDP, 'strcpy'),
[TYPE_VOIDP, TYPE_VOIDP])
buff = "000"
str = f.call(buff, "123")
assert_equal("123", buff)
assert_equal("123", str.to_s)
end
def test_string()
stress, GC.stress = GC.stress, true
f = Function.new(CFunc.new(@libc['strcpy'], TYPE_VOIDP, 'strcpy'),
[TYPE_VOIDP, TYPE_VOIDP])
buff = "000"
str = f.call(buff, "123")
assert_equal("123", buff)
assert_equal("123", str.to_s)
ensure
GC.stress = stress
end
def test_isdigit()
f = Function.new(CFunc.new(@libc['isdigit'], TYPE_INT, 'isdigit'),
[TYPE_INT])
r1 = f.call(?1.ord)
r2 = f.call(?2.ord)
rr = f.call(?r.ord)
assert_positive(r1)
assert_positive(r2)
assert_zero(rr)
end
def test_atof()
f = Function.new(CFunc.new(@libc['atof'], TYPE_DOUBLE, 'atof'),
[TYPE_VOIDP])
r = f.call("12.34")
assert_match(12.00..13.00, r)
end
def test_strtod()
f = Function.new(CFunc.new(@libc['strtod'], TYPE_DOUBLE, 'strtod'),
[TYPE_VOIDP, TYPE_VOIDP])
buff1 = CPtr["12.34"]
buff2 = buff1 + 4
r = f.call(buff1, - buff2)
assert_in_delta(12.34, r, 0.001)
end
def test_qsort1()
assert_separately(%W[--disable=gems -r#{__dir__}/test_base.rb -rdl/func], __FILE__, __LINE__, <<-"end;")
include DL
@libc = dlopen(LIBC_SO)
@libm = dlopen(LIBM_SO)
begin
cb = Function.new(CFunc.new(0, TYPE_INT, '<callback>qsort'),
[TYPE_VOIDP, TYPE_VOIDP]){|x,y| CPtr.new(x)[0] <=> CPtr.new(y)[0]}
qsort = Function.new(CFunc.new(@libc['qsort'], TYPE_VOID, 'qsort'),
[TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP])
buff = "9341"
qsort.call(buff, buff.size, 1, cb)
assert_equal("1349", buff)
bug4929 = '[ruby-core:37395]'
buff = "9341"
EnvUtil.under_gc_stress {qsort.call(buff, buff.size, 1, cb)}
assert_equal("1349", buff, bug4929)
ensure
cb.unbind if cb # max number of callbacks is limited to MAX_CALLBACK
end
end;
end
def test_qsort2()
cb = TempFunction.new(CFunc.new(0, TYPE_INT, '<callback>qsort'),
[TYPE_VOIDP, TYPE_VOIDP])
qsort = Function.new(CFunc.new(@libc['qsort'], TYPE_VOID, 'qsort'),
[TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP])
buff = "9341"
qsort.call(buff, buff.size, 1, cb){|x,y| CPtr.new(x)[0] <=> CPtr.new(y)[0]}
assert_equal("1349", buff)
end
end
end
|