tests: add more auxlib tests

Author: natecraddock

src/tests.zig

@@ -429,6 +429,7 @@ test "version" {
     defer lua.deinit();
 
     try expectEqual(@as(f64, 504), lua.version());
+    lua.checkVersion();
 }
 
 test "string buffers" {
@@ -484,7 +485,8 @@ test "string buffers" {
     b = buffer.prep();
     std.mem.copy(u8, b, "defghijklmnopqrstuvwxyz");
     buffer.pushResultSize(23);
-    try expectEqualStrings("abcdefghijklmnopqrstuvwxyz", try lua.toBytes(-1));
+    try expectEqualStrings("abcdefghijklmnopqrstuvwxyz", lua.toBytesAux(-1));
+    lua.pop(1);
 
     lua.len(-1);
     try expectEqual(@as(Integer, 26), try lua.toInteger(-1));
@@ -1212,7 +1214,8 @@ test "aux check functions" {
     };
 
     lua.pushFunction(function);
-    lua.pushNil();
+    // test pushFail here (currently acts the same as pushNil)
+    lua.pushFail();
     lua.pushInteger(3);
     lua.pushBytes("hello world");
     lua.pushNumber(4);
@@ -1250,17 +1253,86 @@ test "metatables" {
     try expectEqual(@as(Number, 10), try lua.toNumber(-1));
 }
 
+test "aux opt functions" {
+    var lua = try Lua.init(testing.allocator);
+    defer lua.deinit();
+
+    const function = ziglua.wrap(struct {
+        fn inner(l: *Lua) i32 {
+            expectEqual(@as(Integer, 10), l.optInteger(1, 10)) catch unreachable;
+            expectEqualStrings("zig", l.optBytes(2, "zig")) catch unreachable;
+            expectEqual(@as(Number, 1.23), l.optNumber(3, 1.23)) catch unreachable;
+            expectEqualStringsSentinel("lang", l.optString(4, "lang")) catch unreachable;
+            return 0;
+        }
+    }.inner);
+
+    lua.pushFunction(function);
+    try lua.protectedCall(0, 0, 0);
+
+    lua.pushFunction(function);
+    lua.pushInteger(10);
+    lua.pushBytes("zig");
+    lua.pushNumber(1.23);
+    lua.pushString("lang");
+    try lua.protectedCall(4, 0, 0);
+}
+
+test "checkOption" {
+    var lua = try Lua.init(testing.allocator);
+    defer lua.deinit();
+
+    const Variant = enum {
+        one,
+        two,
+        three,
+    };
+
+    const function = ziglua.wrap(struct {
+        fn inner(l: *Lua) i32 {
+            const option = l.checkOption(Variant, 1, .one);
+            l.pushInteger(switch (option) {
+                .one => 1,
+                .two => 2,
+                .three => 3,
+            });
+            return 1;
+        }
+    }.inner);
+
+    lua.pushFunction(function);
+    lua.pushString("one");
+    try lua.protectedCall(1, 1, 0);
+    try expectEqual(@as(Integer, 1), try lua.toInteger(-1));
+    lua.pop(1);
+
+    lua.pushFunction(function);
+    lua.pushString("two");
+    try lua.protectedCall(1, 1, 0);
+    try expectEqual(@as(Integer, 2), try lua.toInteger(-1));
+    lua.pop(1);
+
+    lua.pushFunction(function);
+    lua.pushString("three");
+    try lua.protectedCall(1, 1, 0);
+    try expectEqual(@as(Integer, 3), try lua.toInteger(-1));
+    lua.pop(1);
+
+    // try the default now
+    lua.pushFunction(function);
+    try lua.protectedCall(0, 1, 0);
+    try expectEqual(@as(Integer, 1), try lua.toInteger(-1));
+    lua.pop(1);
+}
+
 test "refs" {
     // temporary test that includes a reference to all functions so
     // they will be type-checked
 
     // auxlib
     _ = Lua.argCheck;
-    _ = Lua.argError;
     _ = Lua.argExpected;
-    _ = Lua.checkOption;
     _ = Lua.checkUserdata;
-    _ = Lua.checkVersion;
     _ = Lua.doFile;
     _ = Lua.raiseErrorAux;
     _ = Lua.exeResult;
@@ -1271,14 +1343,7 @@ test "refs" {
     _ = Lua.loadBufferX;
     _ = Lua.loadFile;
     _ = Lua.loadFileX;
-    _ = Lua.optInteger;
-    _ = Lua.optLString;
-    _ = Lua.optNumber;
-    _ = Lua.optString;
-    _ = Lua.pushFail;
-    _ = Lua.requireF;
     _ = Lua.testUserdata;
-    _ = Lua.toLStringAux;
     _ = Lua.traceback;
     _ = Lua.typeError;
     _ = Lua.typeNameAux;

src/ziglua.zig

@@ -1301,7 +1301,7 @@ pub const Lua = struct {
     }
 
     /// Raises an error reporting a problem with argument `arg` of the C function that called it
-    pub fn argError(lua: *Lua, arg: i32, extra_msg: [:0]const u8) noreturn {
+    pub fn argError(lua: *Lua, arg: i32, extra_msg: [*:0]const u8) noreturn {
         _ = c.luaL_argerror(lua.state, arg, extra_msg);
         unreachable;
     }
@@ -1341,17 +1341,27 @@ pub const Lua = struct {
         return c.luaL_checknumber(lua.state, arg);
     }
 
-    /// Checks whether the function argument `arg` is a string and searches for the string in the null-terminated array `list`
+    /// Checks whether the function argument `arg` is a string and searches for the enum value with the same name in `T`.
     /// `default` is used as a default value when not null
-    /// Returns the index in the array where the string was found
-    pub fn checkOption(lua: *Lua, arg: i32, default: ?[:0]const u8, list: [:null]?[:0]const u8) i32 {
-        return c.luaL_checkoption(
-            lua.state,
-            arg,
-            if (default != null) default.?.ptr else null,
-            // TODO: check this cast
-            @ptrCast([*c]const [*c]const u8, list.ptr),
-        );
+    /// Returns the enum value found
+    /// Useful for mapping Lua strings to Zig enums
+    pub fn checkOption(lua: *Lua, comptime T: type, arg: i32, default: ?T) T {
+        const name = blk: {
+            if (default) |defaultName| {
+                break :blk lua.optBytes(arg, @tagName(defaultName));
+            } else {
+                break :blk lua.checkBytes(arg);
+            }
+        };
+
+        inline for (std.meta.fields(T)) |field| {
+            if (std.mem.eql(u8, field.name, name)) {
+                return @intToEnum(T, field.value);
+            }
+        }
+
+        // NOTE: ptrCast is required because a slice is not supported ziglang/zig/issues/1481
+        return lua.argError(arg, lua.pushFStringEx("invalid option '%s'", .{@ptrCast([*c]const u8, name)}));
     }
 
     /// Grows the stack size to top + `size` elements, raising an error if the stack cannot grow to that size
@@ -1541,14 +1551,14 @@ pub const Lua = struct {
         return c.luaL_optinteger(lua.state, arg, default);
     }
 
-    /// If the function argument `arg` is a string, returns the string
+    /// If the function argument `arg` is a slice of bytes, returns the slice
     /// If the argument is absent or nil returns `default`
-    pub fn optLString(lua: *Lua, arg: i32, default: [:0]const u8) []const u8 {
+    pub fn optBytes(lua: *Lua, arg: i32, default: [:0]const u8) [:0]const u8 {
         var length: usize = 0;
         // will never return null because default cannot be null
         const ret: [*]const u8 = c.luaL_optlstring(lua.state, arg, default, &length);
         if (ret == default.ptr) return default;
-        return ret[0..length];
+        return ret[0..length :0];
     }
 
     /// If the function argument `arg` is a number, returns the number
@@ -1610,10 +1620,10 @@ pub const Lua = struct {
     }
 
     /// Converts any Lua value at the given index into a string in a reasonable format
-    pub fn toLStringAux(lua: *Lua, index: i32) []const u8 {
+    pub fn toBytesAux(lua: *Lua, index: i32) [:0]const u8 {
         var length: usize = undefined;
         const ptr = c.luaL_tolstring(lua.state, index, &length);
-        return ptr[0..length];
+        return ptr[0..length :0];
     }
 
     /// Creates and pushes a traceback of the stack of `other`