stdlib/ext/dl/test/test.rb

   1 # -*- ruby -*-
   2
   3 require 'dl'
   4 require 'dl/import'
   5
   6 $FAIL = 0
   7 $TOTAL = 0
   8
   9 def assert(label, ty, *conds)
  10   $TOTAL += 1
  11   cond = !conds.include?(false)
  12   if( cond )
  13     printf("succeed in `#{label}'\n")
  14   else
  15     $FAIL += 1
  16     case ty
  17     when :may
  18       printf("fail in `#{label}' ... expected\n")
  19     when :must
  20       printf("fail in `#{label}' ... unexpected\n")
  21     when :raise
  22       raise(RuntimeError, "fail in `#{label}'")
  23     end
  24   end
  25 end
  26
  27 def debug(*xs)
  28   if( $DEBUG )
  29     xs.each{|x|
  30       p x
  31     }
  32   end
  33 end
  34
  35 print("DLSTACK   = #{DL::DLSTACK}\n")
  36 print("MAX_ARG   = #{DL::MAX_ARG}\n")
  37 print("\n")
  38 print("DL::FREE = #{DL::FREE.inspect}\n")
  39 print("\n")
  40
  41 $LIB = nil
  42 if( !$LIB && File.exist?("libtest.so") )
  43   $LIB = "./libtest.so"
  44 end
  45 if( !$LIB && File.exist?("test/libtest.so") )
  46   $LIB = "./test/libtest.so"
  47 end
  48
  49 module LIBTest
  50   extend DL::Importable
  51
  52   dlload($LIB)
  53   extern "int test_c2i(char)"
  54   extern "char test_i2c(int)"
  55   extern "long test_lcc(char, char)"
  56   extern "double test_f2d(float)"
  57   extern "float test_d2f(double)"
  58   extern "int test_strlen(char*)"
  59   extern "int test_isucc(int)"
  60   extern "long test_lsucc(long)"
  61   extern "void test_succ(long *)"
  62   extern "int test_arylen(int [])"
  63   extern "void test_append(char*[], int, char *)"
  64 end
  65
  66 DL.dlopen($LIB){|h|
  67   c2i = h["test_c2i","IC"]
  68   debug c2i
  69   r,rs = c2i[?a]
  70   debug r,rs
  71   assert("c2i", :may, r == ?a)
  72   assert("extern c2i", :must, r == LIBTest.test_c2i(?a))
  73
  74   i2c = h["test_i2c","CI"]
  75   debug i2c
  76   r,rs = i2c[?a]
  77   debug r,rs
  78   assert("i2c", :may, r == ?a)
  79   assert("exern i2c", :must, r == LIBTest.test_i2c(?a))
  80
  81   lcc = h["test_lcc","LCC"]
  82   debug lcc
  83   r,rs = lcc[1,2]
  84   assert("lcc", :may, r == 3)
  85   assert("extern lcc", :must, r == LIBTest.test_lcc(1,2))
  86
  87   f2d = h["test_f2d","DF"]
  88   debug f2d
  89   r,rs = f2d[20.001]
  90   debug r,rs
  91   assert("f2d", :may, r.to_i == 20)
  92   assert("extern f2d", :must, r = LIBTest.test_f2d(20.001))
  93
  94   d2f = h["test_d2f","FD"]
  95   debug d2f
  96   r,rs = d2f[20.001]
  97   debug r,rs
  98   assert("d2f", :may, r.to_i == 20)
  99   assert("extern d2f", :must, r == LIBTest.test_d2f(20.001))
 100
 101   strlen = h["test_strlen","IS"]
 102   debug strlen
 103   r,rs = strlen["0123456789"]
 104   debug r,rs
 105   assert("strlen", :must, r == 10)
 106   assert("extern strlen", :must, r == LIBTest.test_strlen("0123456789"))
 107
 108   isucc = h["test_isucc","II"]
 109   debug isucc
 110   r,rs = isucc[2]
 111   debug r,rs
 112   assert("isucc", :must, r == 3)
 113   assert("extern isucc", :must, r == LIBTest.test_isucc(2))
 114
 115   lsucc = h["test_lsucc","LL"]
 116   debug lsucc
 117   r,rs = lsucc[10000000]
 118   debug r,rs
 119   assert("lsucc", :must, r == 10000001)
 120   assert("extern lsucc", :must, r == LIBTest.test_lsucc(10000000))
 121
 122   succ = h["test_succ","0l"]
 123   debug succ
 124   r,rs = succ[0]
 125   debug r,rs
 126   assert("succ", :must, rs[0] == 1)
 127   l = DL.malloc(DL.sizeof("L"))
 128   l.struct!("L",:lval)
 129   LIBTest.test_succ(l)
 130   assert("extern succ", :must, rs[0] == l[:lval])
 131
 132   arylen = h["test_arylen","IA"]
 133   debug arylen
 134   r,rs = arylen[["a","b","c","d",nil]]
 135   debug r,rs
 136   assert("arylen", :must, r == 4)
 137
 138   arylen = h["test_arylen","IP"]
 139   debug arylen
 140   r,rs = arylen[["a","b","c","d",nil]]
 141   debug r,rs
 142   assert("arylen", :must, r == 4)
 143   assert("extern arylen", :must, r == LIBTest.test_arylen(["a","b","c","d",nil]))
 144
 145   append = h["test_append","0aIS"]
 146   debug append
 147   r,rs = append[["a","b","c"],3,"x"]
 148   debug r,rs
 149   assert("append", :must, rs[0].to_a('S',3) == ["ax","bx","cx"])
 150
 151   LIBTest.test_append(["a","b","c"],3,"x")
 152   assert("extern append", :must, rs[0].to_a('S',3) == LIBTest._args_[0].to_a('S',3))
 153
 154   strcat = h["test_strcat","SsS"]
 155   debug strcat
 156   r,rs = strcat["abc\0","x"]
 157   debug r,rs
 158   assert("strcat", :must, rs[0].to_s == "abcx")
 159
 160   init = h["test_init","IiP"]
 161   debug init
 162   argc = 3
 163   argv = ["arg0","arg1","arg2"].to_ptr
 164   r,rs = init[argc, argv.ref]
 165   assert("init", :must, r == 0)
 166 }
 167
 168
 169 h = DL.dlopen($LIB)
 170
 171 sym_open = h["test_open", "PSS"]
 172 sym_gets = h["test_gets", "SsIP"]
 173 sym_close = h["test_close", "0P"]
 174 debug sym_open,sym_gets,sym_close
 175
 176 line = "Hello world!\n"
 177 File.open("tmp.txt", "w"){|f|
 178   f.print(line)
 179 }
 180
 181 fp,rs = sym_open["tmp.txt", "r"]
 182 if( fp )
 183   fp.free = sym_close
 184   r,rs = sym_gets[" " * 256, 256, fp]
 185   debug r,rs
 186   assert("open,gets", :must, rs[0] == line)
 187   ObjectSpace.define_finalizer(fp) {File.unlink("tmp.txt")}
 188   fp = nil
 189 else
 190   assert("open,gets", :must, line == nil)
 191   File.unlink("tmp.txt")
 192 end
 193
 194
 195 callback1 = h["test_callback1"]
 196 debug callback1
 197 r,rs = h["test_call_func1", "IP"][callback1]
 198 debug r,rs
 199 assert("callback1", :must, r == 1)
 200
 201
 202 callback2 = DL.callback("LLP"){|num,ptr|
 203   msg = ptr.to_s
 204   if( msg == "callback message" )
 205     2
 206   else
 207     0
 208   end
 209 }
 210 debug callback2
 211 r,rs = h["test_call_func1", "IP"][callback2]
 212 debug r,rs
 213 assert("callback2", :must, r == 2)
 214 DL.remove_callback(callback2)
 215
 216 ptr = DL.malloc(DL.sizeof('CL'))
 217 ptr.struct!("CL", :c, :l)
 218 ptr["c"] = 0
 219 ptr["l"] = 0
 220 r,rs = h["test_fill_test_struct","0PIL"][ptr,100,1000]
 221 debug r,rs
 222 assert("fill_test_struct", :must, ptr["c"] == 100, ptr["l"] == 1000)
 223 assert("fill_test_struct", :must, ptr[:c] == 100, ptr[:l] == 1000) unless (Fixnum === :-)
 224
 225
 226 r,rs = h["test_alloc_test_struct", "PIL"][100,200]
 227 r.free = DL::FREE
 228 r.struct!("CL", :c, :l)
 229 assert("alloc_test_struct", :must, r["c"] == 100, r["l"] == 200)
 230 assert("alloc_test_struct", :must, r[:c] == 100, r[:l] == 200) unless (Fixnum === :-)
 231
 232 ptr = h["test_strlen"]
 233 sym1 = DL::Symbol.new(ptr,"foo","0")
 234 sym2 = h["test_strlen","LS"]
 235 assert("Symbol.new", :must, ptr == sym1.to_ptr, sym1.to_ptr == sym2.to_ptr)
 236
 237 set_val = h["test_set_long_value","0"]
 238 get_val = h["test_get_long_value","L"]
 239 lval = get_val[][0]
 240 ptr = h["internal_long_value"]
 241 ptr.struct!("L", :l)
 242 assert("get value", :must, ptr["l"] == lval)
 243 assert("get value", :must, ptr[:l] == lval) unless (Fixnum === :-)
 244 ptr["l"] = 200
 245 lval = get_val[][0]
 246 assert("set value", :must, ptr["l"] == lval)
 247 assert("set value", :must, ptr[:l] == lval) unless (Fixnum === :-)
 248
 249
 250 data_init = h["test_data_init", "P"]
 251 data_add  = h["test_data_add", "0PS"]
 252 data_aref = h["test_data_aref", "PPI"]
 253 r,rs = data_init[]
 254 ptr = r
 255 data_add[ptr, "name1"]
 256 data_add[ptr, "name2"]
 257 data_add[ptr, "name3"]
 258
 259 r,rs = data_aref[ptr, 1]
 260 ptr = r
 261 ptr.struct!("C1024P", :name, :next)
 262 assert("data_aref", :must,
 263        ptr["name"].collect{|c| c.chr}.join.split("\0")[0] == "name2")
 264 assert("data_aref", :must,
 265        ptr["name"].collect{|c| c.chr}.join.split("\0")[0] == "name2") unless (Fixnum === :-)
 266
 267 ptr = ptr["next"]
 268 ptr.struct!("C1024P", :name, :next)
 269 assert("data_aref", :must,
 270        ptr["name"].collect{|c| c.chr}.join.split("\0")[0] == "name1")
 271 assert("data_aref", :must,
 272        ptr["name"].collect{|c| c.chr}.join.split("\0")[0] == "name1") unless (Fixnum === :-)
 273
 274 GC.start
 275
 276 ptr = DL::malloc(32)
 277 ptr.struct!("CHIL", "c", "h", "i", "l")
 278 ptr["c"] = 1
 279 ptr["h"] = 2
 280 ptr["i"] = 3
 281 ptr["l"] = 4
 282 assert("struct!", :must,
 283        ptr["c"] == 1 &&
 284        ptr["h"] == 2 &&
 285        ptr["i"] == 3 &&
 286        ptr["l"] == 4)
 287
 288 ptr = DL::malloc(DL::sizeof("IP"))
 289 ptr.struct!("IP", "n", "ptr")
 290 ptr["n"] = 10
 291 ptr["ptr"] = nil
 292 assert("struct!", :must, ptr["n"] == 10 && ptr["ptr"] == nil)
 293
 294 ptr = DL::malloc(16)
 295 ptr.struct!("CICI", "c1", "i1", "c2", "i2")
 296 ptr["c1"] = 0xf1
 297 ptr["c2"] = 0xf2
 298 c1 = [ptr["c1"]].pack("c").unpack("C")[0]
 299 c2 = [ptr["c2"]].pack("c").unpack("C")[0]
 300 assert("struct!", :must,
 301   c1 == 0xf1 &&
 302   c2 == 0xf2)
 303
 304
 305 GC.start
 306 printf("fail/total = #{$FAIL}/#{$TOTAL}\n")