class LuaInRuby_Test

Public Instance Methods

assert_luastack_clean( lstate ) click to toggle source

asserts that the state's stack is empty incorrectly implemented Lua API blocks will trigger this

    # File tests/lua_in_ruby_test.rb
498 def assert_luastack_clean( lstate )
499     assert_equal 0, lstate.__top
500 end
assert_pairs_match( key, val, expected_key, expected_val ) click to toggle source

assert that a given key/value pair match an expected key/value pair

    # File tests/lua_in_ruby_test.rb
503 def assert_pairs_match( key, val, expected_key, expected_val )
504     assert_equal(key, expected_key) if val == expected_val
505 end
test_basic_types() click to toggle source

test the basic types

   # File tests/lua_in_ruby_test.rb
40     def test_basic_types
41         l = Lua::State.new
42 
43         # eval, and basic marshaling
44         assert_nil l.eval('return') 
45         assert_nil l.eval('return nil') 
46         assert_equal 1,     l.eval('return 1') 
47         assert_equal 1.1,   l.eval('return 1.1') 
48         assert_equal 'abc', l.eval('return "abc"') 
49         assert_equal true,  l.eval('return true') 
50         assert_equal false, l.eval('return false')
51         
52         # multi-ret
53         a = l.eval_mult( "return" )
54         assert_instance_of Array, a
55         assert_equal [], a
56         assert_equal 0, a.length
57         a = l.eval_mult( "return 1" )
58         assert_instance_of Array, a
59         assert_equal [1], a
60         assert_equal 1, a.length
61         a = l.eval_mult( "return 1, 2, 3, 4" )
62         assert_instance_of Array, a
63         assert_equal [1,2,3,4], a
64         assert_equal 4, a.length
65 
66         # type id
67         l.eval <<LUA_END
68             f = function() end
69             t = {}
70             u = io.output() -- userdata
71 LUA_END
72         assert_equal Lua::TFUNCTION, l['f'].__type
73         assert_equal Lua::TTABLE,    l.t.__type
74         assert_equal Lua::TUSERDATA, l.u.__type
75         
76        # access queries
77         assert_equal true,   l.indexable?
78         assert_equal true,   l.new_indexable?
79         assert_equal false,  l.callable?
80         assert_equal true,   l.t.indexable?
81         assert_equal true,   l.t.new_indexable?
82         assert_equal false,  l.t.callable?
83         assert_equal false,  l['f'].indexable?
84         assert_equal false,  l['f'].new_indexable?
85         assert_equal true,   l['f'].callable?
86         assert_equal true,   l['u'].indexable?
87         assert_equal false,  l['u'].new_indexable?
88         assert_equal false,  l['u'].callable?
89 
90         assert_luastack_clean l
91    end
test_classes() click to toggle source

test classes

    # File tests/lua_in_ruby_test.rb
443     def test_classes
444         l = Lua::State.new
445 
446         l.eval <<END_LUA
447             Account = {
448                 balance = 0,
449                 deposit = function( self, v )
450                 print "testing testing testing"
451                     self.balance = self.balance + v
452                 end,
453             }
454 END_LUA
455         assert_equal Lua::Table, l.Account.class
456         assert_equal 0, l.Account.balance
457         assert_nothing_thrown { l.Account.deposit! 100 }
458         assert_equal 100, l.Account.balance
459         # DO WE WANT TO DO ANYTHING LIKE THIS?
460         #assert_nothing_thrown { l.Account.!deposit 50 }
461         #assert_equal 150, l.Account.balance
462         #assert_nothing_thrown { l.Account.!deposit! 25 }
463         #assert_equal 175, l.Account.balance
464 
465         assert_luastack_clean l
466     end
test_construction() click to toggle source

test construction of various entities

   # File tests/lua_in_ruby_test.rb
20 def test_construction
21     l = Lua::State.new
22 
23     assert_instance_of Lua::State, l
24     assert_instance_of Lua::Table, l.__globals
25     assert_instance_of Lua::Table, l.__registry
26 
27     assert_equal l, l.__state
28     assert_equal l, l.__globals.__state
29     assert_equal l, l.__registry.__state
30 
31     assert_luastack_clean l
32     
33     assert_raise TypeError do
34         l_bad = Lua::State.new "aa"    
35     end
36 end
test_exceptions() click to toggle source

test exceptions

    # File tests/lua_in_ruby_test.rb
470 def test_exceptions
471     l = Lua::State.new
472 
473     assert_raise SyntaxError do
474         l.eval( 'if !exclamation_doesnt_work then return 0 end' )
475     end
476    
477     assert_raise RuntimeError do
478         l.eval( 'error("42")' )
479     end
480 
481     assert_luastack_clean l
482 end
test_garbage_collection() click to toggle source

test garbage collection makes sure various C-based objects are properly cleaned

    # File tests/lua_in_ruby_test.rb
486 def test_garbage_collection
487     50.times do
488         l = Lua::State.new
489         g = l.__globals
490         l = g = nil
491         GC.start
492     end
493 end
test_libraries() click to toggle source

test libraries

    # File tests/lua_in_ruby_test.rb
110 def test_libraries
111         # invoking libraries
112      l = Lua::State.new
113      assert_nothing_thrown do
114          STDOUT << "you should see-> Hello from Lua!-> "
115          l.eval( 'print "Hello from Lua!"' )
116          STDOUT << "you should see-> Hello again from Lua!-> "
117          l.print "Hello again from Lua!"
118      end
119      assert_luastack_clean l                
120 
121      # loading libraries
122      #####################
123      
124      l = Lua::State.new   # all
125      count = 0 ; l.__globals.each_key { |k| count += 1 }
126      assert_equal 39, count 
127      assert_instance_of Lua::RefObject, l['ipairs']  # base library check
128      assert_instance_of Lua::Table, l.package
129      assert_instance_of Lua::Table, l.table
130      assert_instance_of Lua::Table, l.io
131      assert_instance_of Lua::Table, l.os
132      assert_instance_of Lua::Table, l.string
133      assert_instance_of Lua::Table, l.math
134      assert_instance_of Lua::Table, l.debug
135 
136      l = Lua::State.new( :loadlibs => :all )
137      count = 0 ; l.__globals.each_key { |k| count += 1 }
138      assert_equal 39, count 
139      assert_instance_of Lua::RefObject, l['ipairs']  # base library check
140      assert_instance_of Lua::Table, l.package
141      assert_instance_of Lua::Table, l.table
142      assert_instance_of Lua::Table, l.io
143      assert_instance_of Lua::Table, l.os
144      assert_instance_of Lua::Table, l.string
145      assert_instance_of Lua::Table, l.math
146      assert_instance_of Lua::Table, l.debug
147 
148      l = Lua::State.new( :loadlibs => :none )
149      count = 0 ; l.__globals.each_key { |k| count += 1 }
150      assert_equal 0, count 
151      
152      l = Lua::State.new( :loadlibs => :base )
153      assert_instance_of Lua::RefObject, l['ipairs']  # base library check
154      assert_equal nil, l.string
155      l = Lua::State.new( :loadlibs => :package )
156      assert_instance_of Lua::Table, l.package
157      assert_equal nil, l.string
158      l = Lua::State.new( :loadlibs => :table )
159      assert_instance_of Lua::Table, l.table
160      assert_equal nil, l.string
161      l = Lua::State.new( :loadlibs => :io )
162      assert_instance_of Lua::Table, l.io
163      assert_equal nil, l.string
164      l = Lua::State.new( :loadlibs => :os )
165      assert_instance_of Lua::Table, l.os
166      assert_equal nil, l.string
167      l = Lua::State.new( :loadlibs => :string )
168      assert_instance_of Lua::Table, l.string
169      assert_equal nil, l.io
170      l = Lua::State.new( :loadlibs => :math )
171      assert_instance_of Lua::Table, l.math
172      assert_equal nil, l.string
173      l = Lua::State.new( :loadlibs => :debug )
174      assert_instance_of Lua::Table, l.debug
175       assert_equal nil, l.string
176      
177      l = Lua::State.new( :loadlibs => [:base, :package, :io] )
178      assert_instance_of Lua::RefObject, l['ipairs']  # base library check
179      assert_instance_of Lua::Table, l.package
180      assert_instance_of Lua::Table, l.io
181  end
test_method_dispatch() click to toggle source

test method dispatch

    # File tests/lua_in_ruby_test.rb
390     def test_method_dispatch
391         l = Lua::State.new        
392         l.eval <<END_OF_LUA
393             str = "a"
394             function uniret() return 1 end
395             function uniret2(a) return a end
396             function multiret() return 1, 2, 3 end
397             function multiret2(a,b) return 1, a, b end
398             
399             t = {}
400             t.str = "a"
401             t.uniret = uniret
402             t.uniret2 = uniret2
403             t.multiret = multiret
404             t.multiret2 = multiret2
405 END_OF_LUA
406 
407         assert_equal 'a', l.str
408         assert_equal 'a', l.t.str
409         assert_equal 'a', l.str()   # ugly, but Ruby
410         assert_equal 'a', l.t.str() # ugly, but Ruby
411         assert_kind_of String, l.str
412         assert_kind_of String, l.t.str
413         assert_raise RuntimeError do l.str_   end
414         assert_raise RuntimeError do l.str!   end
415         assert_raise RuntimeError do l.str(2) end
416         
417         assert_kind_of Lua::RefObject, l['uniret']
418         assert_kind_of Float, l.uniret
419         assert_kind_of Float, l.uniret_
420         assert_equal 1, l.uniret()
421         assert_equal 1, l.uniret_
422         assert_equal 1, l.t.uniret
423         assert_equal 1, l.t.uniret()
424         assert_equal 2, l.uniret2(2)
425         assert_equal 2, l.t.uniret2(2)
426         r = l.uniret2 2 ; assert_equal 2, r
427         r = l.t.uniret2 2 ; assert_equal 2, r
428                                  
429         assert_equal [1,2,3], l.multiret
430         assert_equal [1,2,3], l.multiret()
431         assert_equal [1,2,3], l.t.multiret
432         assert_equal [1,2,3], l.t.multiret()
433         assert_equal [1,5,6], l.multiret2( 5, 6 )
434         assert_equal [1,5,6], l.t.multiret2( 5, 6 )
435         r = l.multiret2 5, 6 ; assert_equal [1,5,6], r
436         r = l.t.multiret2 5, 6 ; assert_equal [1,5,6], r
437 
438         assert_luastack_clean l
439     end
test_module() click to toggle source

test module-level entities

   # File tests/lua_in_ruby_test.rb
11 def test_module
12     assert_not_nil( Lua::BRIDGE_VERSION )
13     assert_not_nil( Lua::BRIDGE_VERSION_NUM )
14     assert_not_nil( Lua::LUA_VERSION )
15     assert_not_nil( Lua::LUA_RELEASE )        
16 end
test_setters() click to toggle source

test setters

    # File tests/lua_in_ruby_test.rb
 95 def test_setters
 96     l = Lua::State.new
 97     
 98     l.v = 5   ; assert_equal 5, l.v
 99     l.a = {}  ; assert_instance_of Lua::Table, l.a
100     l.a.v = 7 ; assert_equal 7, l.a.v
101 
102     l['b']   = 6 ; assert_equal 6, l.b               
103     l.a['b'] = 7 ; assert_equal 7, l.a.b               
104     
105    assert_luastack_clean l                
106 end
test_table_access() click to toggle source

test table accesses

    # File tests/lua_in_ruby_test.rb
235     def test_table_access
236         l = Lua::State.new
237         l.eval <<LUA_END
238             a = { 1, 2, 3, 4 }
239             h = { a='x', b='y',
240                   [true]  = 'a',
241                   [false] = 'b',
242                   [1.3]   = 'z', }
243             h2 = { a='x', b='y', }
244 LUA_END
245 
246         assert_instance_of Lua::Table, l.a
247         assert_instance_of Lua::Table, l.h
248         assert_instance_of Lua::Table, l.h2
249         assert_instance_of Lua::Table, l['a']
250         assert_instance_of Lua::Table, l['h']
251         assert_instance_of Lua::Table, l['h2']
252                  
253         assert_nil      l.a[0]
254         assert_equal 1, l.a[1]
255         assert_equal 2, l.a[2]
256         assert_equal 3, l.a[3]
257         assert_equal 4, l.a[4]
258         assert_equal 4, l.a.__length
259 
260         assert_equal 'x', l.h.a
261         assert_equal 'y', l.h.b
262 
263         assert_nil        l.h[0]
264         assert_equal 'x', l.h['a']
265         assert_equal 'y', l.h['b']
266 
267         assert_equal 'z', l.h[1.3]
268         assert_equal 'a', l.h[true]
269         assert_equal 'b', l.h[false]
270         assert_equal 0,   l.h.__length  # length only applies to Array
271 
272         temp = (l.a[10] = 'x')
273         assert_equal 'x', temp
274         assert_equal 'x', l.a[10]
275 
276         assert_instance_of Array,     l.a.to_array
277         assert_instance_of Hash,      l.h2.to_hash
278         assert_equal( [1,2,3,4],      l.a.to_array)
279         assert_equal( {'a' => 'x','b' => 'y'}, l.h2.to_hash)
280 
281         assert_luastack_clean l
282     end
test_table_creation_from_ruby() click to toggle source

test table creation from ruby

    # File tests/lua_in_ruby_test.rb
185 def test_table_creation_from_ruby
186     l = Lua::State.new
187 
188     l.eval( "a = {}")
189     assert_instance_of Lua::Table, l.a
190 
191     s = "return {1,2,3}"
192     assert_instance_of Lua::Table, l.eval(s)
193     assert_equal 3, l.eval(s).__length
194     assert_equal [1,2,3], l.eval(s).to_array
195     
196     b = l.new_table_at 'b'
197     assert_instance_of Lua::Table, b
198     assert_instance_of Lua::Table, l.b
199 
200     b = l.a.new_table_at 'b'
201     assert_instance_of Lua::Table, b
202     assert_instance_of Lua::Table, l.a.b
203     
204     l.c = []
205     assert_instance_of Lua::Table, l.c
206     assert_equal 0, l.c.__length
207     
208     l.d = {}
209     assert_instance_of Lua::Table, l.d
210     assert_equal 0, l.d.__length
211             
212     e = [1,2,3,4]
213     l.e = e
214     assert_equal 1, l.e[1]
215     assert_equal 2, l.e[2]
216     assert_equal 3, l.e[3]
217     assert_equal 4, l.e[4]
218     assert_equal e, l.e.to_array
219     assert_instance_of Lua::Table, l.e
220 
221     f = { 1=>1, 2=>2, 'a'=>3, 'b'=>4 }
222     l.f = f
223     assert_equal 1, l.f[1]
224     assert_equal 2, l.f[2]
225     assert_equal 3, l.f['a']
226     assert_equal 4, l.f['b']
227     assert_equal 2, l.f.__length
228     assert_instance_of Lua::Table, l.f
229     
230     assert_luastack_clean l
231 end
test_table_iteration() click to toggle source

test table iteration

    # File tests/lua_in_ruby_test.rb
286 def test_table_iteration
287     l = Lua::State.new
288 
289     # array integer iteration
290     l.eval( "array = { 100, 200, 300, 400 }" )
291     assert_instance_of Lua::Table, l.array                
292     n = 0 ; l.array.each_ipair { |k,v| n += 1
293         assert_pairs_match( k, v, 1, 100 )
294         assert_pairs_match( k, v, 2, 200 )
295         assert_pairs_match( k, v, 3, 300 )
296         assert_pairs_match( k, v, 4, 400 )
297     }
298     assert_equal(4, n)         
299 
300     n = 0 ; l.array.each_ikey { |k| n += 1
301         assert_pairs_match( n, k, 1, 1 )
302         assert_pairs_match( n, k, 2, 2 )
303         assert_pairs_match( n, k, 3, 3 )
304         assert_pairs_match( n, k, 4, 4 )
305         assert( n <= 4 )
306     }
307     assert_equal(4, n)
308 
309     sumv = n = 0 ; l.array.each_ivalue { |v| n += 1
310         sumv += v
311         assert_equal(v, n*100)
312     }
313     assert_equal(4, n) ; assert_equal(1000, sumv)         
314 
315     # hash integer iteration
316     l.eval( "hsh = { [1]=100, [2]=200, a=300, b=400, }" )
317     assert_instance_of Lua::Table, l.hsh
318     n = 0 ; l.hsh.each_ipair { |k,v| n += 1
319         assert_pairs_match( k, v, 1, 100 )
320         assert_pairs_match( k, v, 2, 200 )
321         assert_pairs_match( k, v, 'a', 300 )
322         assert_pairs_match( k, v, 'b', 400 )
323     }
324     assert_equal(2, n)         
325 
326     sumk = n = 0 ; l.hsh.each_ikey { |k| n += 1
327         sumk += k
328     }
329     assert_equal(2, n) ; assert_equal(3, sumk)         
330 
331     sumv = n = 0 ; l.hsh.each_ivalue { |v| n += 1
332         sumv += v
333         assert_equal(v, n*100)
334     }
335     assert_equal(2, n) ; assert_equal(300, sumv)         
336             
337     # array assoc iteration
338     l.eval( "array = { 100, 200, 300, 400 }" )
339     assert_instance_of Lua::Table, l.array                
340     n = 0 ; l.array.each_pair { |k,v| n += 1
341         assert_pairs_match( k, v, 1, 100 )
342         assert_pairs_match( k, v, 2, 200 )
343         assert_pairs_match( k, v, 3, 300 )
344         assert_pairs_match( k, v, 4, 400 )
345     }
346     assert_equal(4, n)         
347 
348     sumk = n = 0 ; l.array.each_key { |k| n += 1
349         sumk += k
350         assert_equal(k, n)
351     }
352     assert_equal(4, n) ; assert_equal(10, sumk)         
353 
354     sumv = n = 0 ; l.array.each_ivalue { |v| n += 1
355         sumv += v
356         assert_equal(v, n*100)
357     }
358     assert_equal(4, n) ; assert_equal(1000, sumv)         
359 
360     # hash assoc iteration
361     l.eval( "hsh = { [1]=100, [2]=200, a=300, b=400, }" )
362     assert_instance_of Lua::Table, l.array                
363     n = 0 ; l.hsh.each_pair { |k,v| n += 1
364         assert_pairs_match( k, v, 1, 100 )
365         assert_pairs_match( k, v, 2, 200 )
366         assert_pairs_match( k, v, 'a', 300 )
367         assert_pairs_match( k, v, 'b', 400 )
368     }
369     assert_equal( n, 4)
370 
371     n = 0 ; l.hsh.each_key { |k| n += 1 
372         assert_pairs_match( n, k, 1, 100 )
373         assert_pairs_match( n, k, 2, 200 )
374         assert_pairs_match( n, k, 3, 'a' )
375         assert_pairs_match( n, k, 4, 'b' )
376     }
377     assert_equal( n, 4)
378     
379     n = sumv = 0 ; l.hsh.each_value { |v| n += 1
380         sumv += v
381     }
382     assert_equal(4, n) ; assert_equal( sumv, 1000)
383 
384     # done iteration tests
385     assert_luastack_clean l
386 end