# File tests/lua_in_ruby_test.rb, line 502
502:     def assert_luastack_clean( lstate )
503:         assert_equal 0, lstate.__top
504:     end

     # File tests/lua_in_ruby_test.rb, line 507
507:     def assert_pairs_match( key, val, expected_key, expected_val )
508:         assert_equal(key, expected_key) if val == expected_val
509:     end

    # File tests/lua_in_ruby_test.rb, line 40
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 "            f = function() end\n            t = {}\n            u = io.output() -- userdata\n"
68:         assert_equal Lua::TFUNCTION, l['f'].__type
69:         assert_equal Lua::TTABLE,    l.t.__type
70:         assert_equal Lua::TUSERDATA, l.u.__type
71:         
72:        # access queries
73:         assert_equal true,   l.indexable?
74:         assert_equal true,   l.new_indexable?
75:         assert_equal false,  l.callable?
76:         assert_equal true,   l.t.indexable?
77:         assert_equal true,   l.t.new_indexable?
78:         assert_equal false,  l.t.callable?
79:         assert_equal false,  l['f'].indexable?
80:         assert_equal false,  l['f'].new_indexable?
81:         assert_equal true,   l['f'].callable?
82:         assert_equal true,   l['u'].indexable?
83:         assert_equal false,  l['u'].new_indexable?
84:         assert_equal false,  l['u'].callable?
85: 
86:         assert_luastack_clean l
87:    end

     # File tests/lua_in_ruby_test.rb, line 446
446:     def test_classes
447:         l = Lua::State.new
448: 
449:         l.eval "            Account = {\n                balance = 0,\n                deposit = function( self, v )\n                print \"testing testing testing\"\n                    self.balance = self.balance + v\n                end,\n            }\n"
450:         assert_equal Lua::Table, l.Account.class
451:         assert_equal 0, l.Account.balance
452:         assert_nothing_thrown { l.Account.deposit! 100 }
453:         assert_equal 100, l.Account.balance
454:         # DO WE WANT TO DO ANYTHING LIKE THIS?
455:         #assert_nothing_thrown { l.Account.!deposit 50 }
456:         #assert_equal 150, l.Account.balance
457:         #assert_nothing_thrown { l.Account.!deposit! 25 }
458:         #assert_equal 175, l.Account.balance
459: 
460:         assert_luastack_clean l
461:     end

    # File tests/lua_in_ruby_test.rb, line 20
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

     # File tests/lua_in_ruby_test.rb, line 474
474:     def test_exceptions
475:         l = Lua::State.new
476: 
477:         assert_raise SyntaxError do
478:             l.eval( 'if !exclamation_doesnt_work then return 0 end' )
479:         end
480:        
481:         assert_raise RuntimeError do
482:             l.eval( 'error("42")' )
483:         end
484: 
485:         assert_luastack_clean l
486:     end

     # File tests/lua_in_ruby_test.rb, line 490
490:     def test_garbage_collection
491:         50.times do
492:             l = Lua::State.new
493:             g = l.__globals
494:             l = g = nil
495:             GC.start
496:         end
497:     end

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

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

    # File tests/lua_in_ruby_test.rb, line 11
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

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

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

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

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