Methods
- assert_luastack_clean
- assert_pairs_match
- test_basic_types
- test_classes
- test_construction
- test_exceptions
- test_garbage_collection
- test_libraries
- test_method_dispatch
- test_module
- test_setters
- test_table_access
- test_table_creation_from_ruby
- test_table_iteration
Public Instance methods
asserts that the state‘s stack is empty incorrectly implemented Lua API blocks will trigger this
[ show source ]
# File tests/lua_in_ruby_test.rb, line 502 502: def assert_luastack_clean( lstate ) 503: assert_equal 0, lstate.__top 504: end
assert that a given key/value pair match an expected key/value pair
[ show source ]
# 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
test the basic types
[ show source ]
# 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
test classes
[ show source ]
# 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
test construction of various entities
[ show source ]
# 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
test exceptions
[ show source ]
# 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
test garbage collection makes sure various C-based objects are properly cleaned
[ show source ]
# 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
test libraries
[ show source ]
# 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
test method dispatch
[ show source ]
# 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
test module-level entities
[ show source ]
# 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
test setters
[ show source ]
# 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
test table accesses
[ show source ]
# 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
test table creation from ruby
[ show source ]
# 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
test table iteration
[ show source ]
# 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