tests: finish main library tests!

The main Lua API library is tested! The tests are very surface level,
but do provide a measure of security against changes now.

Author: natecraddock

build.zig

@@ -6,7 +6,7 @@ const LibExeObjStep = std.build.LibExeObjStep;
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
 
-    const tests = b.addTest("src/ziglua.zig");
+    const tests = b.addTest("src/tests.zig");
     link(b, tests, .{ .use_apicheck = true });
     tests.setBuildMode(mode);
 

src/tests.zig

@@ -886,18 +886,100 @@ test "registry" {
     try expectEqualStrings("hello there", lua.toString(-1).?);
 }
 
+test "closing vars" {
+    var lua = try Lua.init(testing.allocator);
+    defer lua.deinit();
+
+    lua.open(.{ .base = true });
+
+    // do setup in Lua for ease
+    try lua.doString(
+        \\closed_vars = 0
+        \\mt = { __close = function() closed_vars = closed_vars + 1 end }
+    );
+
+    lua.newTable();
+    _ = lua.getGlobal("mt");
+    lua.setMetatable(-2);
+    lua.toClose(-1);
+    lua.closeSlot(-1);
+    lua.pop(1);
+
+    lua.newTable();
+    _ = lua.getGlobal("mt");
+    lua.setMetatable(-2);
+    lua.toClose(-1);
+    lua.closeSlot(-1);
+    lua.pop(1);
+
+    // this should have incremented "closed_vars" to 2
+    _ = lua.getGlobal("closed_vars");
+    try expectEqual(@as(Number, 2), lua.toNumber(-1));
+}
+
+test "raise error" {
+    var lua = try Lua.init(testing.allocator);
+    defer lua.deinit();
+
+    const makeError = struct {
+        fn inner(l: *Lua) i32 {
+            _ = l.pushString("makeError made an error");
+            l.raiseError();
+            return 0;
+        }
+    }.inner;
+
+    lua.pushCFunction(ziglua.wrap(makeError));
+    try expectError(Error.Runtime, lua.protectedCall(0, 0, 0));
+    try expectEqualStrings("makeError made an error", lua.toString(-1).?);
+}
+
+fn continuation(l: *Lua, status: Lua.StatusType, ctx: isize) i32 {
+    _ = status;
+
+    if (ctx == 5) {
+        _ = l.pushString("done");
+        return 1;
+    } else {
+        // yield the current context value
+        l.pushInteger(ctx);
+        return l.yieldCont(1, ctx + 1, ziglua.wrap(continuation));
+    }
+}
+
+test "yielding" {
+    var lua = try Lua.init(testing.allocator);
+    defer lua.deinit();
+
+    // here we create some zig functions that will run 5 times, continutally
+    // yielding a count until it finally returns the string "done"
+    const willYield = struct {
+        fn inner(l: *Lua) i32 {
+            return continuation(l, .ok, 0);
+        }
+    }.inner;
+
+    var thread = lua.newThread();
+    thread.pushCFunction(ziglua.wrap(willYield));
+
+    try expect(!lua.isYieldable());
+    try expect(thread.isYieldable());
+
+    var results: i32 = undefined;
+    var i: i32 = 0;
+    while (i < 5) : (i += 1) {
+        try expectEqual(Lua.ResumeStatus.yield, try thread.resumeThread(lua, 0, &results));
+        try expectEqual(@as(Integer, i), thread.toInteger(-1));
+        thread.pop(results);
+    }
+    try expectEqual(Lua.ResumeStatus.ok, try thread.resumeThread(lua, 0, &results));
+    try expectEqualStrings("done", thread.toString(-1).?);
+}
+
 test "refs" {
     // temporary test that includes a reference to all functions so
     // they will be type-checked
 
-    // stdlib
-    _ = Lua.closeSlot;
-    _ = Lua.raiseError;
-    _ = Lua.isYieldable;
-    _ = Lua.toClose;
-    _ = Lua.yield;
-    _ = Lua.yieldCont;
-
     // debug
     _ = Lua.getHook;
     _ = Lua.getHookCount;

src/ziglua.zig

@@ -818,11 +818,21 @@ pub const Lua = struct {
         if (c.lua_resetthread(lua.state) != Status.ok) return Error.Fail;
     }
 
+    pub const ResumeStatus = enum(u1) {
+        ok = Status.ok,
+        yield = Status.yield,
+    };
+
     /// Starts and resumes a coroutine in the given thread
-    /// TODO: look into possible errors returned
-    pub fn resumeThread(lua: *Lua, from: ?Lua, num_args: i32, num_results: *i32) i32 {
+    pub fn resumeThread(lua: *Lua, from: ?Lua, num_args: i32, num_results: *i32) !ResumeStatus {
         const from_state = if (from) |from_val| from_val.state else null;
-        return c.lua_resume(lua.state, from_state, num_args, num_results);
+        const thread_status = c.lua_resume(lua.state, from_state, num_args, num_results);
+        switch (thread_status) {
+            Status.err_runtime => return Error.Runtime,
+            Status.err_memory => return Error.Memory,
+            Status.err_error => return Error.MsgHandler,
+            else => return @intToEnum(ResumeStatus, thread_status),
+        }
     }
 
     /// Rotates the stack elements between the valid `index` and the top of the stack
@@ -1664,7 +1674,7 @@ pub inline fn opaqueCast(comptime T: type, ptr: *anyopaque) *T {
 
 pub const ZigFn = fn (lua: *Lua) i32;
 pub const ZigHookFn = fn (lua: *Lua, ar: *DebugInfo) void;
-pub const ZigContFn = fn (lua: *Lua, status: bool, ctx: KContext) c_int;
+pub const ZigContFn = fn (lua: *Lua, status: Lua.StatusType, ctx: KContext) i32;
 pub const ZigReaderFn = fn (lua: *Lua, data: *anyopaque) ?[]const u8;
 pub const ZigWarnFn = fn (data: ?*anyopaque, msg: []const u8, to_cont: bool) void;
 pub const ZigWriterFn = fn (lua: *Lua, buf: []const u8, data: *anyopaque) bool;
@@ -1729,7 +1739,7 @@ fn wrapZigContFn(comptime f: ZigContFn) CContFn {
         fn inner(state: ?*LuaState, status: c_int, ctx: KContext) callconv(.C) c_int {
             // this is called by Lua, state should never be null
             var lua: Lua = .{ .state = state.? };
-            return @call(.{ .modifier = .always_inline }, f, .{ &lua, status != 0, ctx });
+            return @call(.{ .modifier = .always_inline }, f, .{ &lua, @intToEnum(Lua.StatusType, status), ctx });
         }
     }.inner;
 }