class LuaInRuby_Test

# File tests/lua_in_ruby_test.rb, line 498
def assert_luastack_clean( lstate )
    assert_equal 0, lstate.__top
end

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

# File tests/lua_in_ruby_test.rb, line 40
    def test_basic_types
        l = Lua::State.new

        # eval, and basic marshaling
        assert_nil l.eval('return') 
        assert_nil l.eval('return nil') 
        assert_equal 1,     l.eval('return 1') 
        assert_equal 1.1,   l.eval('return 1.1') 
        assert_equal 'abc', l.eval('return "abc"') 
        assert_equal true,  l.eval('return true') 
        assert_equal false, l.eval('return false')
        
        # multi-ret
        a = l.eval_mult( "return" )
        assert_instance_of Array, a
        assert_equal [], a
        assert_equal 0, a.length
        a = l.eval_mult( "return 1" )
        assert_instance_of Array, a
        assert_equal [1], a
        assert_equal 1, a.length
        a = l.eval_mult( "return 1, 2, 3, 4" )
        assert_instance_of Array, a
        assert_equal [1,2,3,4], a
        assert_equal 4, a.length

        # type id
        l.eval <<LUA_END
            f = function() end
            t = {}
            u = io.output() -- userdata
LUA_END
        assert_equal Lua::TFUNCTION, l['f'].__type
        assert_equal Lua::TTABLE,    l.t.__type
        assert_equal Lua::TUSERDATA, l.u.__type
        
       # access queries
        assert_equal true,   l.indexable?
        assert_equal true,   l.new_indexable?
        assert_equal false,  l.callable?
        assert_equal true,   l.t.indexable?
        assert_equal true,   l.t.new_indexable?
        assert_equal false,  l.t.callable?
        assert_equal false,  l['f'].indexable?
        assert_equal false,  l['f'].new_indexable?
        assert_equal true,   l['f'].callable?
        assert_equal true,   l['u'].indexable?
        assert_equal false,  l['u'].new_indexable?
        assert_equal false,  l['u'].callable?

        assert_luastack_clean l
   end

# File tests/lua_in_ruby_test.rb, line 443
    def test_classes
        l = Lua::State.new

        l.eval <<END_LUA
            Account = {
                balance = 0,
                deposit = function( self, v )
                print "testing testing testing"
                    self.balance = self.balance + v
                end,
            }
END_LUA
        assert_equal Lua::Table, l.Account.class
        assert_equal 0, l.Account.balance
        assert_nothing_thrown { l.Account.deposit! 100 }
        assert_equal 100, l.Account.balance
        # DO WE WANT TO DO ANYTHING LIKE THIS?
        #assert_nothing_thrown { l.Account.!deposit 50 }
        #assert_equal 150, l.Account.balance
        #assert_nothing_thrown { l.Account.!deposit! 25 }
        #assert_equal 175, l.Account.balance

        assert_luastack_clean l
    end

# File tests/lua_in_ruby_test.rb, line 20
def test_construction
    l = Lua::State.new

    assert_instance_of Lua::State, l
    assert_instance_of Lua::Table, l.__globals
    assert_instance_of Lua::Table, l.__registry

    assert_equal l, l.__state
    assert_equal l, l.__globals.__state
    assert_equal l, l.__registry.__state

    assert_luastack_clean l
    
    assert_raise TypeError do
        l_bad = Lua::State.new "aa"    
    end
end

# File tests/lua_in_ruby_test.rb, line 470
def test_exceptions
    l = Lua::State.new

    assert_raise SyntaxError do
        l.eval( 'if !exclamation_doesnt_work then return 0 end' )
    end
   
    assert_raise RuntimeError do
        l.eval( 'error("42")' )
    end

    assert_luastack_clean l
end

# File tests/lua_in_ruby_test.rb, line 486
def test_garbage_collection
    50.times do
        l = Lua::State.new
        g = l.__globals
        l = g = nil
        GC.start
    end
end

# File tests/lua_in_ruby_test.rb, line 110
def test_libraries
        # invoking libraries
     l = Lua::State.new
     assert_nothing_thrown do
         STDOUT << "you should see-> Hello from Lua!-> "
         l.eval( 'print "Hello from Lua!"' )
         STDOUT << "you should see-> Hello again from Lua!-> "
         l.print "Hello again from Lua!"
     end
     assert_luastack_clean l                

     # loading libraries
     #####################
     
     l = Lua::State.new   # all
     count = 0 ; l.__globals.each_key { |k| count += 1 }
     assert_equal 39, count 
     assert_instance_of Lua::RefObject, l['ipairs']  # base library check
     assert_instance_of Lua::Table, l.package
     assert_instance_of Lua::Table, l.table
     assert_instance_of Lua::Table, l.io
     assert_instance_of Lua::Table, l.os
     assert_instance_of Lua::Table, l.string
     assert_instance_of Lua::Table, l.math
     assert_instance_of Lua::Table, l.debug

     l = Lua::State.new( :loadlibs => :all )
     count = 0 ; l.__globals.each_key { |k| count += 1 }
     assert_equal 39, count 
     assert_instance_of Lua::RefObject, l['ipairs']  # base library check
     assert_instance_of Lua::Table, l.package
     assert_instance_of Lua::Table, l.table
     assert_instance_of Lua::Table, l.io
     assert_instance_of Lua::Table, l.os
     assert_instance_of Lua::Table, l.string
     assert_instance_of Lua::Table, l.math
     assert_instance_of Lua::Table, l.debug

     l = Lua::State.new( :loadlibs => :none )
     count = 0 ; l.__globals.each_key { |k| count += 1 }
     assert_equal 0, count 
     
     l = Lua::State.new( :loadlibs => :base )
     assert_instance_of Lua::RefObject, l['ipairs']  # base library check
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :package )
     assert_instance_of Lua::Table, l.package
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :table )
     assert_instance_of Lua::Table, l.table
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :io )
     assert_instance_of Lua::Table, l.io
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :os )
     assert_instance_of Lua::Table, l.os
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :string )
     assert_instance_of Lua::Table, l.string
     assert_equal nil, l.io
     l = Lua::State.new( :loadlibs => :math )
     assert_instance_of Lua::Table, l.math
     assert_equal nil, l.string
     l = Lua::State.new( :loadlibs => :debug )
     assert_instance_of Lua::Table, l.debug
      assert_equal nil, l.string
     
     l = Lua::State.new( :loadlibs => [:base, :package, :io] )
     assert_instance_of Lua::RefObject, l['ipairs']  # base library check
     assert_instance_of Lua::Table, l.package
     assert_instance_of Lua::Table, l.io
 end

# File tests/lua_in_ruby_test.rb, line 390
    def test_method_dispatch
        l = Lua::State.new        
        l.eval <<END_OF_LUA
            str = "a"
            function uniret() return 1 end
            function uniret2(a) return a end
            function multiret() return 1, 2, 3 end
            function multiret2(a,b) return 1, a, b end
            
            t = {}
            t.str = "a"
            t.uniret = uniret
            t.uniret2 = uniret2
            t.multiret = multiret
            t.multiret2 = multiret2
END_OF_LUA

        assert_equal 'a', l.str
        assert_equal 'a', l.t.str
        assert_equal 'a', l.str()   # ugly, but Ruby 
        assert_equal 'a', l.t.str() # ugly, but Ruby
        assert_kind_of String, l.str
        assert_kind_of String, l.t.str
        assert_raise RuntimeError do l.str_   end
        assert_raise RuntimeError do l.str!   end
        assert_raise RuntimeError do l.str(2) end
        
        assert_kind_of Lua::RefObject, l['uniret']
        assert_kind_of Float, l.uniret
        assert_kind_of Float, l.uniret_
        assert_equal 1, l.uniret()
        assert_equal 1, l.uniret_
        assert_equal 1, l.t.uniret
        assert_equal 1, l.t.uniret()
        assert_equal 2, l.uniret2(2)
        assert_equal 2, l.t.uniret2(2)
        r = l.uniret2 2 ; assert_equal 2, r
        r = l.t.uniret2 2 ; assert_equal 2, r
                                 
        assert_equal [1,2,3], l.multiret
        assert_equal [1,2,3], l.multiret()
        assert_equal [1,2,3], l.t.multiret
        assert_equal [1,2,3], l.t.multiret()
        assert_equal [1,5,6], l.multiret2( 5, 6 )
        assert_equal [1,5,6], l.t.multiret2( 5, 6 )
        r = l.multiret2 5, 6 ; assert_equal [1,5,6], r
        r = l.t.multiret2 5, 6 ; assert_equal [1,5,6], r

        assert_luastack_clean l
    end

# File tests/lua_in_ruby_test.rb, line 11
def test_module
    assert_not_nil( Lua::BRIDGE_VERSION )
    assert_not_nil( Lua::BRIDGE_VERSION_NUM )
    assert_not_nil( Lua::LUA_VERSION )
    assert_not_nil( Lua::LUA_RELEASE )        
end

# File tests/lua_in_ruby_test.rb, line 95
def test_setters
    l = Lua::State.new
    
    l.v = 5   ; assert_equal 5, l.v
    l.a = {}  ; assert_instance_of Lua::Table, l.a
    l.a.v = 7 ; assert_equal 7, l.a.v

    l['b']   = 6 ; assert_equal 6, l.b               
    l.a['b'] = 7 ; assert_equal 7, l.a.b               
    
   assert_luastack_clean l                
end

# File tests/lua_in_ruby_test.rb, line 235
    def test_table_access
        l = Lua::State.new
        l.eval <<LUA_END
            a = { 1, 2, 3, 4 }
            h = { a='x', b='y',
                  [true]  = 'a',
                  [false] = 'b',
                  [1.3]   = 'z', }
            h2 = { a='x', b='y', }
LUA_END

        assert_instance_of Lua::Table, l.a
        assert_instance_of Lua::Table, l.h
        assert_instance_of Lua::Table, l.h2
        assert_instance_of Lua::Table, l['a']
        assert_instance_of Lua::Table, l['h']
        assert_instance_of Lua::Table, l['h2']
                 
        assert_nil      l.a[0]
        assert_equal 1, l.a[1]
        assert_equal 2, l.a[2]
        assert_equal 3, l.a[3]
        assert_equal 4, l.a[4]
        assert_equal 4, l.a.__length

        assert_equal 'x', l.h.a
        assert_equal 'y', l.h.b

        assert_nil        l.h[0]
        assert_equal 'x', l.h['a']
        assert_equal 'y', l.h['b']

        assert_equal 'z', l.h[1.3]
        assert_equal 'a', l.h[true]
        assert_equal 'b', l.h[false]
        assert_equal 0,   l.h.__length  # length only applies to Array

        temp = (l.a[10] = 'x')
        assert_equal 'x', temp
        assert_equal 'x', l.a[10]

        assert_instance_of Array,     l.a.to_array
        assert_instance_of Hash,      l.h2.to_hash
        assert_equal( [1,2,3,4],      l.a.to_array)
        assert_equal( {'a' => 'x','b' => 'y'}, l.h2.to_hash)

        assert_luastack_clean l
    end

# File tests/lua_in_ruby_test.rb, line 185
def test_table_creation_from_ruby
    l = Lua::State.new

    l.eval( "a = {}")
    assert_instance_of Lua::Table, l.a

    s = "return {1,2,3}"
    assert_instance_of Lua::Table, l.eval(s)
    assert_equal 3, l.eval(s).__length
    assert_equal [1,2,3], l.eval(s).to_array
    
    b = l.new_table_at 'b'
    assert_instance_of Lua::Table, b
    assert_instance_of Lua::Table, l.b

    b = l.a.new_table_at 'b'
    assert_instance_of Lua::Table, b
    assert_instance_of Lua::Table, l.a.b
    
    l.c = []
    assert_instance_of Lua::Table, l.c
    assert_equal 0, l.c.__length
    
    l.d = {}
    assert_instance_of Lua::Table, l.d
    assert_equal 0, l.d.__length
            
    e = [1,2,3,4]
    l.e = e
    assert_equal 1, l.e[1]
    assert_equal 2, l.e[2]
    assert_equal 3, l.e[3]
    assert_equal 4, l.e[4]
    assert_equal e, l.e.to_array
    assert_instance_of Lua::Table, l.e

    f = { 1=>1, 2=>2, 'a'=>3, 'b'=>4 }
    l.f = f
    assert_equal 1, l.f[1]
    assert_equal 2, l.f[2]
    assert_equal 3, l.f['a']
    assert_equal 4, l.f['b']
    assert_equal 2, l.f.__length
    assert_instance_of Lua::Table, l.f
    
    assert_luastack_clean l
end

# File tests/lua_in_ruby_test.rb, line 286
def test_table_iteration
    l = Lua::State.new

    # array integer iteration
    l.eval( "array = { 100, 200, 300, 400 }" )
    assert_instance_of Lua::Table, l.array                
    n = 0 ; l.array.each_ipair { |k,v| n += 1
        assert_pairs_match( k, v, 1, 100 )
        assert_pairs_match( k, v, 2, 200 )
        assert_pairs_match( k, v, 3, 300 )
        assert_pairs_match( k, v, 4, 400 )
    }
    assert_equal(4, n)         

    n = 0 ; l.array.each_ikey { |k| n += 1
        assert_pairs_match( n, k, 1, 1 )
        assert_pairs_match( n, k, 2, 2 )
        assert_pairs_match( n, k, 3, 3 )
        assert_pairs_match( n, k, 4, 4 )
        assert( n <= 4 )
    }
    assert_equal(4, n)

    sumv = n = 0 ; l.array.each_ivalue { |v| n += 1
        sumv += v
        assert_equal(v, n*100)
    }
    assert_equal(4, n) ; assert_equal(1000, sumv)         

    # hash integer iteration
    l.eval( "hsh = { [1]=100, [2]=200, a=300, b=400, }" )
    assert_instance_of Lua::Table, l.hsh
    n = 0 ; l.hsh.each_ipair { |k,v| n += 1
        assert_pairs_match( k, v, 1, 100 )
        assert_pairs_match( k, v, 2, 200 )
        assert_pairs_match( k, v, 'a', 300 )
        assert_pairs_match( k, v, 'b', 400 )
    }
    assert_equal(2, n)         

    sumk = n = 0 ; l.hsh.each_ikey { |k| n += 1
        sumk += k
    }
    assert_equal(2, n) ; assert_equal(3, sumk)         

    sumv = n = 0 ; l.hsh.each_ivalue { |v| n += 1
        sumv += v
        assert_equal(v, n*100)
    }
    assert_equal(2, n) ; assert_equal(300, sumv)         
            
    # array assoc iteration
    l.eval( "array = { 100, 200, 300, 400 }" )
    assert_instance_of Lua::Table, l.array                
    n = 0 ; l.array.each_pair { |k,v| n += 1
        assert_pairs_match( k, v, 1, 100 )
        assert_pairs_match( k, v, 2, 200 )
        assert_pairs_match( k, v, 3, 300 )
        assert_pairs_match( k, v, 4, 400 )
    }
    assert_equal(4, n)         

    sumk = n = 0 ; l.array.each_key { |k| n += 1
        sumk += k
        assert_equal(k, n)
    }
    assert_equal(4, n) ; assert_equal(10, sumk)         

    sumv = n = 0 ; l.array.each_ivalue { |v| n += 1
        sumv += v
        assert_equal(v, n*100)
    }
    assert_equal(4, n) ; assert_equal(1000, sumv)         

    # hash assoc iteration
    l.eval( "hsh = { [1]=100, [2]=200, a=300, b=400, }" )
    assert_instance_of Lua::Table, l.array                
    n = 0 ; l.hsh.each_pair { |k,v| n += 1
        assert_pairs_match( k, v, 1, 100 )
        assert_pairs_match( k, v, 2, 200 )
        assert_pairs_match( k, v, 'a', 300 )
        assert_pairs_match( k, v, 'b', 400 )
    }
    assert_equal( n, 4)

    n = 0 ; l.hsh.each_key { |k| n += 1 
        assert_pairs_match( n, k, 1, 100 )
        assert_pairs_match( n, k, 2, 200 )
        assert_pairs_match( n, k, 3, 'a' )
        assert_pairs_match( n, k, 4, 'b' )
    }
    assert_equal( n, 4)
    
    n = sumv = 0 ; l.hsh.each_value { |v| n += 1
        sumv += v
    }
    assert_equal(4, n) ; assert_equal( sumv, 1000)

    # done iteration tests
    assert_luastack_clean l
end