authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2023-06-25 03:14:08+01:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2023-06-25 13:28:32+01:00
logfec7565da6e27334de63c3635dd2e32325c39c98
tree6a9427f77e8b6043259b4107f86a5748d8057745
parentd249629ef1345e6f1ff03ff1381fa526da97e9e5
signaturelock-open Commit is signed but in an unrecognized format.

behavior: add tests for cast builtins coercing to optional and error union

1 files changed, 122 insertions(+), 0 deletions(-)

test/behavior/cast.zig+122
......@@ -2219,3 +2219,125 @@ test "peer type resolution: pointer attributes are combined correctly" {
22192219 try expectEqualSlices(u8, std.mem.span(@volatileCast(r2)), "bar");
22202220 try expectEqualSlices(u8, std.mem.span(@volatileCast(r3)), "baz");
22212221}
2222
2223test "cast builtins can wrap result in optional" {
2224 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2225 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2226 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2227 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2228 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2229 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
2230
2231 const S = struct {
2232 const MyEnum = enum(u32) { _ };
2233 fn a() ?MyEnum {
2234 return @enumFromInt(123);
2235 }
2236 fn b() ?u32 {
2237 return @intFromFloat(42.50);
2238 }
2239 fn c() ?*const f32 {
2240 const x: u32 = 1;
2241 return @ptrCast(&x);
2242 }
2243
2244 fn doTheTest() !void {
2245 const ra = a() orelse return error.ImpossibleError;
2246 const rb = b() orelse return error.ImpossibleError;
2247 const rc = c() orelse return error.ImpossibleError;
2248
2249 comptime assert(@TypeOf(ra) == MyEnum);
2250 comptime assert(@TypeOf(rb) == u32);
2251 comptime assert(@TypeOf(rc) == *const f32);
2252
2253 try expect(@intFromEnum(ra) == 123);
2254 try expect(rb == 42);
2255 try expect(@as(*const u32, @ptrCast(rc)).* == 1);
2256 }
2257 };
2258
2259 try S.doTheTest();
2260 try comptime S.doTheTest();
2261}
2262
2263test "cast builtins can wrap result in error union" {
2264 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2265 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2266 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2267 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2268 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2269 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
2270
2271 const S = struct {
2272 const MyEnum = enum(u32) { _ };
2273 const E = error{ImpossibleError};
2274 fn a() E!MyEnum {
2275 return @enumFromInt(123);
2276 }
2277 fn b() E!u32 {
2278 return @intFromFloat(42.50);
2279 }
2280 fn c() E!*const f32 {
2281 const x: u32 = 1;
2282 return @ptrCast(&x);
2283 }
2284
2285 fn doTheTest() !void {
2286 const ra = try a();
2287 const rb = try b();
2288 const rc = try c();
2289
2290 comptime assert(@TypeOf(ra) == MyEnum);
2291 comptime assert(@TypeOf(rb) == u32);
2292 comptime assert(@TypeOf(rc) == *const f32);
2293
2294 try expect(@intFromEnum(ra) == 123);
2295 try expect(rb == 42);
2296 try expect(@as(*const u32, @ptrCast(rc)).* == 1);
2297 }
2298 };
2299
2300 try S.doTheTest();
2301 try comptime S.doTheTest();
2302}
2303
2304test "cast builtins can wrap result in error union and optional" {
2305 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2306 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2307 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2308 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2309 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2310 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
2311
2312 const S = struct {
2313 const MyEnum = enum(u32) { _ };
2314 const E = error{ImpossibleError};
2315 fn a() E!?MyEnum {
2316 return @enumFromInt(123);
2317 }
2318 fn b() E!?u32 {
2319 return @intFromFloat(42.50);
2320 }
2321 fn c() E!?*const f32 {
2322 const x: u32 = 1;
2323 return @ptrCast(&x);
2324 }
2325
2326 fn doTheTest() !void {
2327 const ra = try a() orelse return error.ImpossibleError;
2328 const rb = try b() orelse return error.ImpossibleError;
2329 const rc = try c() orelse return error.ImpossibleError;
2330
2331 comptime assert(@TypeOf(ra) == MyEnum);
2332 comptime assert(@TypeOf(rb) == u32);
2333 comptime assert(@TypeOf(rc) == *const f32);
2334
2335 try expect(@intFromEnum(ra) == 123);
2336 try expect(rb == 42);
2337 try expect(@as(*const u32, @ptrCast(rc)).* == 1);
2338 }
2339 };
2340
2341 try S.doTheTest();
2342 try comptime S.doTheTest();
2343}