Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
const builtin = @import("builtin");
test: Add test cases for the new capture behavior
2020-02-14 15:56:34 +01:00
const std = @import("std");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
self hosted tests import std library
2017-01-05 03:57:48 -05:00
rename some behavior tests
2017-09-09 22:53:32 -04:00
test "if statements" {
IR: port some tests
2016-12-22 00:20:14 -05:00
shouldBeEqual(1, 1);
firstEqlThird(2, 1, 2);
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
fn shouldBeEqual(a: i32, b: i32) void {
IR: port some tests
2016-12-22 00:20:14 -05:00
if (a != b) {
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 04:58:48 -04:00
unreachable;
IR: port some tests
2016-12-22 00:20:14 -05:00
} else {
return;
}
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
fn firstEqlThird(a: i32, b: i32, c: i32) void {
IR: port some tests
2016-12-22 00:20:14 -05:00
if (a == b) {
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 04:58:48 -04:00
unreachable;
IR: port some tests
2016-12-22 00:20:14 -05:00
} else if (b == c) {
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 04:58:48 -04:00
unreachable;
IR: port some tests
2016-12-22 00:20:14 -05:00
} else if (a == c) {
return;
} else {
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 04:58:48 -04:00
unreachable;
IR: port some tests
2016-12-22 00:20:14 -05:00
}
}
rename some behavior tests
2017-09-09 22:53:32 -04:00
test "else if expression" {
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(elseIfExpressionF(1) == 1);
IR: port more tests
2016-12-22 01:42:30 -05:00
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
fn elseIfExpressionF(c: u8) u8 {
IR: port more tests
2016-12-22 01:42:30 -05:00
if (c == 0) {
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
return 0;
IR: port more tests
2016-12-22 01:42:30 -05:00
} else if (c == 1) {
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
return 1;
IR: port more tests
2016-12-22 01:42:30 -05:00
} else {
update the codebase to use `@as`
2019-11-06 23:25:57 -05:00
return @as(u8, 2);
IR: port more tests
2016-12-22 01:42:30 -05:00
}
}
Fix too eager comptime evaluation of error ptr
2019-05-14 23:30:31 +02:00
// #2297
var global_with_val: anyerror!u32 = 0;
var global_with_err: anyerror!u32 = error.SomeError;
test "unwrap mutable global var" {
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
Port more behavior tests
2022-02-22 14:15:09 +01:00
Fix too eager comptime evaluation of error ptr
2019-05-14 23:30:31 +02:00
if (global_with_val) |v| {
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(v == 0);
fix code broken from previous commit
2021-06-19 21:10:22 -04:00
} else |_| {
Fix too eager comptime evaluation of error ptr
2019-05-14 23:30:31 +02:00
unreachable;
}
if (global_with_err) |_| {
unreachable;
} else |e| {
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(e == error.SomeError);
Fix too eager comptime evaluation of error ptr
2019-05-14 23:30:31 +02:00
}
}
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
test "labeled break inside comptime if inside runtime if" {
var answer: i32 = 0;
var c = true;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &c;
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
if (c) {
answer = if (true) blk: {
update the codebase to use `@as`
2019-11-06 23:25:57 -05:00
break :blk @as(i32, 42);
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
};
}
update usage of std.testing in behavior and standalone tests
2021-05-04 21:23:22 +03:00
try expect(answer == 42);
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
}
AstGen: fix if, orelse, catch, with unreachable bodies Before, the system to replace a result location pointer with a traditional break instruction did not notice the case when one of the bodies was unreachable. Now, the emitted ZIR code is improved and simplified in this case, resulting in a new passing behavior test.
2021-10-02 19:09:54 -07:00
test "const result loc, runtime if cond, else unreachable" {
const Num = enum { One, Two };
var t = true;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &t;
AstGen: fix if, orelse, catch, with unreachable bodies Before, the system to replace a result location pointer with a traditional break instruction did not notice the case when one of the bodies was unreachable. Now, the emitted ZIR code is improved and simplified in this case, resulting in a new passing behavior test.
2021-10-02 19:09:54 -07:00
const x = if (t) Num.Two else unreachable;
try expect(x == .Two);
}
C backend: fix crash when number of Decls passes a threshold The ensureUnusedCapacity did not reserve a big enough number. I changed it to no longer guess the capacity because I saw that the number of possible items was not determinable ahead of time and this can therefore avoid allocating more memory than necessary.
2021-10-28 17:23:02 -07:00
test "if copies its payload" {
Port more behavior tests
2022-02-22 14:15:09 +01:00
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Port more behavior tests
2022-02-22 14:15:09 +01:00
C backend: fix crash when number of Decls passes a threshold The ensureUnusedCapacity did not reserve a big enough number. I changed it to no longer guess the capacity because I saw that the number of possible items was not determinable ahead of time and this can therefore avoid allocating more memory than necessary.
2021-10-28 17:23:02 -07:00
const S = struct {
fn doTheTest() !void {
var tmp: ?i32 = 10;
if (tmp) |value| {
// Modify the original variable
tmp = null;
try expect(value == 10);
} else unreachable;
}
};
try S.doTheTest();
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest();
C backend: fix crash when number of Decls passes a threshold The ensureUnusedCapacity did not reserve a big enough number. I changed it to no longer guess the capacity because I saw that the number of possible items was not determinable ahead of time and this can therefore avoid allocating more memory than necessary.
2021-10-28 17:23:02 -07:00
}
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
test "if prongs cast to expected type instead of peer type resolution" {
const S = struct {
fn doTheTest(f: bool) !void {
var x: i32 = 0;
x = if (f) 1 else 2;
try expect(x == 2);
var b = true;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &b;
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
const y: i32 = if (b) 1 else 2;
try expect(y == 1);
}
};
try S.doTheTest(false);
all: replace `comptime try` with `try comptime` Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-05 14:29:28 +06:00
try comptime S.doTheTest(false);
organize behavior tests Every test that is moved in this commit has been checked to see if it is now passing.
2022-01-25 23:29:02 -07:00
}
Revert "AstGen: preserve inferred ptr result loc for breaks" This reverts commit 8bf3e1f8d0902abd4133e2729b3625c25011c3ff, which introduced miscompilations for peer expressions any time they needed coercions to runtime types. I opened #11957 as a proposal to accomplish the goal of the reverted commit. Closes #11898
2022-06-28 17:56:28 -07:00
test "if peer expressions inferred optional type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Revert "AstGen: preserve inferred ptr result loc for breaks" This reverts commit 8bf3e1f8d0902abd4133e2729b3625c25011c3ff, which introduced miscompilations for peer expressions any time they needed coercions to runtime types. I opened #11957 as a proposal to accomplish the goal of the reverted commit. Closes #11898
2022-06-28 17:56:28 -07:00
var self: []const u8 = "abcdef";
var index: usize = 0;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &self, &index };
const left_index = (index << 1) + 1;
const right_index = left_index + 1;
const left = if (left_index < self.len) self[left_index] else null;
const right = if (right_index < self.len) self[right_index] else null;
Revert "AstGen: preserve inferred ptr result loc for breaks" This reverts commit 8bf3e1f8d0902abd4133e2729b3625c25011c3ff, which introduced miscompilations for peer expressions any time they needed coercions to runtime types. I opened #11957 as a proposal to accomplish the goal of the reverted commit. Closes #11898
2022-06-28 17:56:28 -07:00
try expect(left_index < self.len);
try expect(right_index < self.len);
try expect(left.? == 98);
try expect(right.? == 99);
}
Sema: fix coerce_result_ptr in case of inferred result type Previously, the logic for analyzing coerce_result_ptr would generate invalid bitcast instructions which did not include coercion logic, such as optional wrapping, resulting in miscompilations. Now, the logic of resolve_inferred_alloc goes back over all the placeholders inserted by coerce_result_ptr, and replaces them with logic doing the proper coercions. Closes #12045
2022-07-14 16:48:44 -07:00
test "if-else expression with runtime condition result location is inferred optional" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
stage2: sparc64: Skip unimplemented tests
2022-10-11 20:39:47 +07:00
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
Sema: fix coerce_result_ptr in case of inferred result type Previously, the logic for analyzing coerce_result_ptr would generate invalid bitcast instructions which did not include coercion logic, such as optional wrapping, resulting in miscompilations. Now, the logic of resolve_inferred_alloc goes back over all the placeholders inserted by coerce_result_ptr, and replaces them with logic doing the proper coercions. Closes #12045
2022-07-14 16:48:44 -07:00
const A = struct { b: u64, c: u64 };
var d: bool = true;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = &d;
Sema: fix coerce_result_ptr in case of inferred result type Previously, the logic for analyzing coerce_result_ptr would generate invalid bitcast instructions which did not include coercion logic, such as optional wrapping, resulting in miscompilations. Now, the logic of resolve_inferred_alloc goes back over all the placeholders inserted by coerce_result_ptr, and replaces them with logic doing the proper coercions. Closes #12045
2022-07-14 16:48:44 -07:00
const e = if (d) A{ .b = 15, .c = 30 } else null;
try expect(e != null);
}
Sema: fix coerceResultPtr It did not handle properly when the dummy operand was a comptime_int; it was crashing in coerce because comptime_int is supposed to be comptime-known. So when calling coerceResultPtr, we pass the actual operand, not a dummy operand, which means it will have the proper comptime value when necessary.
2022-07-14 18:10:54 -07:00
test "result location with inferred type ends up being pointer to comptime_int" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Sema: fix coerceResultPtr It did not handle properly when the dummy operand was a comptime_int; it was crashing in coerce because comptime_int is supposed to be comptime-known. So when calling coerceResultPtr, we pass the actual operand, not a dummy operand, which means it will have the proper comptime value when necessary.
2022-07-14 18:10:54 -07:00
var a: ?u32 = 1234;
var b: u32 = 2000;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &a, &b };
const c = if (a) |d| blk: {
Sema: fix coerceResultPtr It did not handle properly when the dummy operand was a comptime_int; it was crashing in coerce because comptime_int is supposed to be comptime-known. So when calling coerceResultPtr, we pass the actual operand, not a dummy operand, which means it will have the proper comptime value when necessary.
2022-07-14 18:10:54 -07:00
if (d < b) break :blk @as(u32, 1);
break :blk 0;
} else @as(u32, 0);
try expect(c == 1);
}
behavior: if-@as-if chain Closes #8952
2023-05-28 03:15:49 +02:00
test "if-@as-if chain" {
var fast = true;
var very_fast = false;
test: update behavior to silence 'var is never mutated' errors
2023-11-16 13:21:18 +00:00
_ = .{ &fast, &very_fast };
behavior: if-@as-if chain Closes #8952
2023-05-28 03:15:49 +02:00
const num_frames = if (fast)
@as(u32, if (very_fast) 16 else 4)
else
1;
try expect(num_frames == 4);
}
Liveness: fix branch operands becoming aliased
2024-01-02 13:08:26 +03:00
fn returnTrue() bool {
return true;
}
test "if value shouldn't be load-elided if used later (structs)" {
const Foo = struct { x: i32 };
var a = Foo{ .x = 1 };
var b = Foo{ .x = 1 };
const c = if (@call(.never_inline, returnTrue, .{})) a else b;
// The second variable is superfluous with the current
// state of codegen optimizations, but in future
// "if (smthg) a else a" may be optimized simply into "a".
a.x = 2;
b.x = 3;
try std.testing.expectEqual(c.x, 1);
}
test "if value shouldn't be load-elided if used later (optionals)" {
riscv: add stage2_riscv to test matrix and bypass failing tests
2024-04-13 23:11:32 -07:00
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
Liveness: fix branch operands becoming aliased
2024-01-02 13:08:26 +03:00
var a: ?i32 = 1;
var b: ?i32 = 1;
const c = if (@call(.never_inline, returnTrue, .{})) a else b;
a = 2;
b = 3;
try std.testing.expectEqual(c, 1);
}
categorize `behavior/bugs/<issueno>.zig` tests
2024-01-02 17:33:41 +02:00
test "variable type inferred from if expression" {
var a = if (true) {
return;
} else true;
_ = &a;
return error.TestFailed;
}
Reference in New Issue Copy Permalink