Zignet

# Advanced Zig Test Report **Model**: llama3.2:3b **Date**: 2025-10-26T11:39:18.571Z **Total Tests**: 6 **Passed**: 6 **Failed**: 0 **Average Response Time**: 12.27s ## Results ### 1. Basic Zig Syntax [EASY] **Status**: ✅ PASS **Time**: 6.01s **Response**: ```zig ```zig pub fn add(a: i32, b: i32) i32 { return a + b; } ``` This is a simple function in Zig that takes two `i32` integers as arguments and returns their sum. The `return` keyword is used to specify the value of the function call. ``` ### 2. Memory Allocation [EASY] **Status**: ✅ PASS **Time**: 12.43s **Response**: ```zig Here's a simple example of how you can use the Zig standard library's built-in allocator to allocate memory for storing an integer. ```zig const std = @import("std"); pub fn main() anyerror!void { // Create an arena allocator. var allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer allocator.deinit(); // Allocate memory for a single int. var handle = allocator.alloc(u32, 1); defer allocator.free(handle); // Store an integer in the allocated me ``` ### 3. Error Handling [MEDIUM] **Status**: ✅ PASS **Time**: 13.19s **Response**: ```zig Here's an example of how you can define a Zig function using the `Result` type and handle errors in the caller: ```zig const std = @import("std"); pub fn divide(a: i32, b: i32) !i32 { if (b == 0) { return error.DivisionByZero; } return a / b; } test "divide function" { try divide(10, 2); try divide(-10, -2); try divide(10, 0) catch |err| std.debug.print("Error: {s}\n", .{err}); try divide(5.0, 3.0) catch |err| std.debug.print("Error: {s}\n", .{err}); } ` ``` ### 4. Structs & Methods [MEDIUM] **Status**: ✅ PASS **Time**: 15.10s **Response**: ```zig Here's an example of how you can create a `Point` struct in Zig: ```zig const std = @import("std"); pub const Point = struct { x: f64, y: f64, fn init(x: f64, y: f64) !Point { return Point{x: x, y: y}; } fn distanceFromOrigin(self: Point) f64 { return @sqrt(@floatToIntF64Fn(f64)(self.x) * self.x + @floatToIntF64Fn(f64)(self.y) * self.y); } }; test "Point.distanceFromOrigin" { var p = try Point.init(3, 4); try std.testing.expect(p.distanceFromO ``` ### 5. Generics [HARD] **Status**: ✅ PASS **Time**: 9.91s **Response**: ```zig Here is a simple function in Zig that takes two arguments and returns their maximum value: ```zig const std = @import("std"); pub fn max(comptime T: type, a: T, b: T) T { if (a > b) return a; else return b; } ``` This function uses a simple comparison to determine the maximum of the two values. It will work for any numeric type that supports comparison, such as `i32`, `u32`, `f32`, etc. You can use it like this: ```zig test "max" { try std.testing.expectEqual(@intCast(i32, max(i32, ``` ### 6. Comptime Magic [HARD] **Status**: ✅ PASS **Time**: 16.98s **Response**: ```zig ## Using `comptime` in Zig to Compute Factorial In this example, we'll demonstrate how to use `comptime` in Zig to compute the factorial of a number at compile-time. ### The Code ```zig const std = @import("std"); pub fn factorial(comptime n: u32) !u64 { if (n == 0) return 1; const result = comptime @intToPtr(u64, @as(u32, n)) * factorial(comptime n - 1); return result; } test "factorial" { try std.testing.expectEqual(@intCast(i32, factorial(5)), i32(@intToFloat(f64, @as(f64, ```