MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42802 0 0 Zig
Normal View History Raw
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
const std = @import("std.zig");
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const builtin = @import("builtin");
add std.testing.random_seed closes #17609
2024-07-22 16:03:11 -07:00
const assert = std.debug.assert;
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
const math = std.math;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
add std.testing.random_seed closes #17609
2024-07-22 16:03:11 -07:00
/// Provides deterministic randomness in unit tests.
/// Initialized on startup. Read-only after that.
pub var random_seed: u32 = 0;
std.testing.FailingAllocator: flatten namespace
2025-02-03 20:00:01 -08:00
pub const FailingAllocator = @import("testing/FailingAllocator.zig");
pub const failing_allocator = failing_allocator_instance.allocator();
std.testing: make some things not pub this looks like it was an accident to expose these
2025-02-05 14:24:41 -08:00
var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.allocator(), .{
.fail_index = 0,
});
var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
Promoted "leak_count_allocator" to the main testing.allocator
2020-01-29 21:22:01 -06:00
Move debug.global_allocator to testing.allocator
2020-01-29 12:21:29 -06:00
/// This should only be used in temporary test programs.
allocgate: renamed getAllocator function to allocator
2021-10-29 02:08:41 +01:00
pub const allocator = allocator_instance.allocator();
std.testing: make some things not pub this looks like it was an accident to expose these
2025-02-05 14:24:41 -08:00
pub var allocator_instance: std.heap.GeneralPurposeAllocator(.{
std.testing: don't ask wasm to stack trace
2025-02-06 14:46:16 -08:00
.stack_trace_frames = if (std.debug.sys_can_stack_trace) 10 else 0,
std.testing.allocator: different canary + enable resize traces Accept a slight performance degradation when unit testing for better debuggability when a leak or double-free is detected.
2025-02-05 16:39:14 -08:00
.resize_stack_traces = true,
// A unique value so that when a default-constructed
// GeneralPurposeAllocator is incorrectly passed to testing allocator, or
// vice versa, panic occurs.
.canary = @truncate(0x2731e675c3a701ba),
std.testing: make some things not pub this looks like it was an accident to expose these
2025-02-05 14:24:41 -08:00
}) = b: {
if (!builtin.is_test) @compileError("testing allocator used when not testing");
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
break :b .init;
std: compile error on invalid testing allocator usage
2022-05-26 14:19:05 +04:30
};
Move debug.global_allocator to testing.allocator
2020-01-29 12:21:29 -06:00
start to make test runner aware of logging by default the test runner will only print logs with "warning" or higher. this can be configured via the std.testing API. See #5738 for future plans
2020-07-08 21:01:13 -07:00
/// TODO https://github.com/ziglang/zig/issues/5738
pub var log_level = std.log.Level.warn;
std.testing: disable expectEqualSlices printing for spirv
2023-10-08 21:00:20 +02:00
// Disable printing in tests for simple backends.
riscv: finally fix bug + `airAggregateInit` i just hadn't realized that I placed the `riscv_start` branch in the non-simplified starts
2024-04-16 22:44:55 -07:00
pub const backend_can_print = !(builtin.zig_backend == .stage2_spirv64 or builtin.zig_backend == .stage2_riscv64);
std.testing: disable expectEqualSlices printing for spirv
2023-10-08 21:00:20 +02:00
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
fn print(comptime fmt: []const u8, args: anytype) void {
std.testing: allow print() at comptime This allows functions like expectEqual to be performed at comptime. If an error is detected, the result is logged via a compile error.
2023-10-08 17:02:59 +02:00
if (@inComptime()) {
@compileError(std.fmt.comptimePrint(fmt, args));
std.testing: disable expectEqualSlices printing for spirv
2023-10-08 21:00:20 +02:00
} else if (backend_can_print) {
std.testing: allow print() at comptime This allows functions like expectEqual to be performed at comptime. If an error is detected, the result is logged via a compile error.
2023-10-08 17:02:59 +02:00
std.debug.print(fmt, args);
}
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
}
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
/// This function is intended to be used only in tests. It prints diagnostics to stderr
std.testing: fix incorrect docs that mentioned aborting At some point we changed these functions to return errors instead of aborting.
2022-03-17 17:23:22 -07:00
/// and then returns a test failure error when actual_error_union is not expected_error.
allow tests to fail
2021-05-04 19:36:59 +03:00
pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (actual_error_union) |actual_payload| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
std.testing.expectError: fix error names
2024-11-08 22:03:34 -05:00
return error.TestExpectedError;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
} else |actual_error| {
if (expected_error != actual_error) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected error.{s}, found error.{s}\n", .{
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
@errorName(expected_error),
@errorName(actual_error),
});
std.testing.expectError: fix error names
2024-11-08 22:03:34 -05:00
return error.TestUnexpectedError;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
}
}
/// This function is intended to be used only in tests. When the two values are not
/// equal, prints diagnostics to stderr to show exactly how they are not equal,
std.testing: fix incorrect docs that mentioned aborting At some point we changed these functions to return errors instead of aborting.
2022-03-17 17:23:22 -07:00
/// then returns a test failure error.
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
/// `actual` and `expected` are coerced to a common type using peer type resolution.
pub inline fn expectEqual(expected: anytype, actual: anytype) !void {
const T = @TypeOf(expected, actual);
return expectEqualInner(T, expected, actual);
}
fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 21:56:19 +01:00
switch (@typeInfo(@TypeOf(actual))) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.noreturn,
.@"opaque",
.frame,
.@"anyframe",
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 21:56:19 +01:00
=> @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.undefined,
.null,
.void,
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
=> return,
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.type => {
std: Better handling of type values in expectEqual
2020-10-29 11:10:21 +01:00
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std: Better handling of type values in expectEqual
2020-10-29 11:10:21 +01:00
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.bool,
.int,
.float,
.comptime_float,
.comptime_int,
.enum_literal,
.@"enum",
.@"fn",
.error_set,
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
=> {
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {}, found {}\n", .{ expected, actual });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.pointer => |pointer| {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
switch (pointer.size) {
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
.one, .many, .c => {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {*}, found {*}\n", .{ expected, actual });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
},
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
.slice => {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (actual.ptr != expected.ptr) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected slice ptr {*}, found {*}\n", .{ expected.ptr, actual.ptr });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
if (actual.len != expected.len) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
},
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.array => |array| try expectEqualSlices(array.child, &expected, &actual),
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.vector => |info| {
Vector comparison in meta and testing
2020-01-07 19:14:37 +05:00
var i: usize = 0;
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
while (i < info.len) : (i += 1) {
Vector comparison in meta and testing
2020-01-07 19:14:37 +05:00
if (!std.meta.eql(expected[i], actual[i])) {
std.testing.expectEqual: {any} in print and move tests
2024-10-09 02:44:41 +08:00
print("index {d} incorrect. expected {any}, found {any}\n", .{
stage2: implement `@ctz` and `@clz` including SIMD AIR: * `array_elem_val` is now allowed to be used with a vector as the array type. * New instructions: splat, vector_init AstGen: * The splat ZIR instruction uses coerced_ty for the ResultLoc, avoiding an unnecessary `as` instruction, since the coercion will be performed in Sema. * Builtins that accept vectors now ignore the type parameter. Comment from this commit reproduced here: The accepted proposal #6835 tells us to remove the type parameter from these builtins. To stay source-compatible with stage1, we still observe the parameter here, but we do not encode it into the ZIR. To implement this proposal in stage2, only AstGen code will need to be changed. Sema: * `clz` and `ctz` ZIR instructions are now handled by the same function which accept AIR tag and comptime eval function pointer to differentiate. * `@typeInfo` for vectors is implemented. * `@splat` is implemented. It takes advantage of `Value.Tag.repeated` 😎 * `elemValue` is implemented for vectors, when the index is a scalar. Handling a vector index is still TODO. * Element-wise coercion is implemented for vectors. It could probably be optimized a bit, but it is at least complete & correct. * `Type.intInfo` supports vectors, returning int info for the element. * `Value.ctz` initial implementation. Needs work. * `Value.eql` is implemented for arrays and vectors. LLVM backend: * Implement vector support when lowering `array_elem_val`. * Implement vector support when lowering `ctz` and `clz`. * Implement `splat` and `vector_init`.
2022-01-12 23:53:26 -07:00
i, expected[i], actual[i],
});
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
Vector comparison in meta and testing
2020-01-07 19:14:37 +05:00
}
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"struct" => |structType| {
std: testing.expectEqual on structs now works
2019-05-21 00:29:46 +10:00
inline for (structType.fields) |field| {
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(@field(expected, field.name), @field(actual, field.name));
std: testing.expectEqual on structs now works
2019-05-21 00:29:46 +10:00
}
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"union" => |union_info| {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (union_info.tag_type == null) {
std.testing: improve compile error on untagged union equality
2025-02-10 23:05:38 -05:00
@compileError("Unable to compare untagged union values for type " ++ @typeName(@TypeOf(actual)));
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
Replace @TagType uses, mostly with std.meta.Tag
2021-01-11 11:19:24 -07:00
const Tag = std.meta.Tag(@TypeOf(expected));
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
Replace @TagType uses, mostly with std.meta.Tag
2021-01-11 11:19:24 -07:00
const expectedTag = @as(Tag, expected);
const actualTag = @as(Tag, actual);
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(expectedTag, actualTag);
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
fix std.testing.expectEqual for comptime-only union switch from `inline for` with `std.mem.eql` to `inline else` and tag comparison; expectEqualDeep(Inner) was already doing this. add a previously-failing test case.
2024-06-18 19:01:05 +02:00
// we only reach this switch if the tags are equal
switch (expected) {
inline else => |val, tag| try expectEqual(val, @field(actual, @tagName(tag))),
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
}
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.optional => {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (expected) |expected_payload| {
if (actual) |actual_payload| {
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(expected_payload, actual_payload);
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {any}, found null\n", .{expected_payload});
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
} else {
if (actual) |actual_payload| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected null, found {any}\n", .{actual_payload});
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.error_union => {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (expected) |expected_payload| {
if (actual) |actual_payload| {
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(expected_payload, actual_payload);
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
} else |actual_err| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {any}, found {}\n", .{ expected_payload, actual_err });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
} else |expected_err| {
if (actual) |actual_payload| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {}, found {any}\n", .{ expected_err, actual_payload });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
} else |actual_err| {
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(expected_err, actual_err);
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
}
},
}
}
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
test "expectEqual.union(enum)" {
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
const T = union(enum) {
a: i32,
b: f32,
};
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
const a10 = T{ .a = 10 };
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqual(a10, a10);
Implements std.testing.expectEqual for tagged unions. (#3773)
2019-11-27 22:35:32 +01:00
}
fix std.testing.expectEqual for comptime-only union switch from `inline for` with `std.mem.eql` to `inline else` and tag comparison; expectEqualDeep(Inner) was already doing this. add a previously-failing test case.
2024-06-18 19:01:05 +02:00
test "expectEqual union with comptime-only field" {
const U = union(enum) {
a: void,
b: void,
c: comptime_int,
};
try expectEqual(U{ .a = {} }, .a);
}
std.testing.expectEqual: {any} in print and move tests
2024-10-09 02:44:41 +08:00
test "expectEqual nested array" {
const a = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
const b = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
try expectEqual(a, b);
}
test "expectEqual vector" {
const a: @Vector(4, u32) = @splat(4);
const b: @Vector(4, u32) = @splat(4);
try expectEqual(a, b);
}
test "expectEqual null" {
const a = .{null};
const b = @Vector(1, ?*u8){null};
try expectEqual(a, b);
}
Move fmt.testFmt to testing.expectFmt
2021-01-11 20:30:43 -05:00
/// This function is intended to be used only in tests. When the formatted result of the template
/// and its arguments does not equal the expected text, it prints diagnostics to stderr to show how
testing.expectFmt() - reuse expectEqualStrings()
2024-02-26 19:08:27 -08:00
/// they are not equal, then returns an error. It depends on `expectEqualStrings()` for printing
/// diagnostics.
Move fmt.testFmt to testing.expectFmt
2021-01-11 20:30:43 -05:00
pub fn expectFmt(expected: []const u8, comptime template: []const u8, args: anytype) !void {
testing.expectFmt() - reuse expectEqualStrings()
2024-02-26 19:08:27 -08:00
const actual = try std.fmt.allocPrint(allocator, template, args);
defer allocator.free(actual);
return expectEqualStrings(expected, actual);
Move fmt.testFmt to testing.expectFmt
2021-01-11 20:30:43 -05:00
}
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
/// This function is intended to be used only in tests. When the actual value is
/// not approximately equal to the expected value, prints diagnostics to stderr
std.testing: fix incorrect docs that mentioned aborting At some point we changed these functions to return errors instead of aborting.
2022-03-17 17:23:22 -07:00
/// to show exactly how they are not equal, then returns a test failure error.
fix(text): hyphenation and other fixes
2022-10-03 19:52:39 +02:00
/// See `math.approxEqAbs` for more information on the tolerance parameter.
/// The types must be floating-point.
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
/// `actual` and `expected` are coerced to a common type using peer type resolution.
pub inline fn expectApproxEqAbs(expected: anytype, actual: anytype, tolerance: anytype) !void {
const T = @TypeOf(expected, actual, tolerance);
return expectApproxEqAbsInner(T, expected, actual, tolerance);
}
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
fn expectApproxEqAbsInner(comptime T: type, expected: T, actual: T, tolerance: T) !void {
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
switch (@typeInfo(T)) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedApproxEqAbs;
},
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.comptime_float => @compileError("Cannot approximately compare two comptime_float values"),
Add expectWithinMargin and test
2020-06-23 18:05:32 +02:00
else => @compileError("Unable to compare non floating point values"),
}
}
std: promote tests to doctests Now these show up as "example usage" in generated documentation.
2024-03-13 15:56:09 -07:00
test expectApproxEqAbs {
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
const pos_x: T = 12.0;
const pos_y: T = 12.06;
const neg_x: T = -12.0;
const neg_y: T = -12.06;
Add expectWithinMargin and test
2020-06-23 18:05:32 +02:00
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectApproxEqAbs(pos_x, pos_y, 0.1);
try expectApproxEqAbs(neg_x, neg_y, 0.1);
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
}
Add expectWithinMargin and test
2020-06-23 18:05:32 +02:00
}
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
/// This function is intended to be used only in tests. When the actual value is
/// not approximately equal to the expected value, prints diagnostics to stderr
std.testing: fix incorrect docs that mentioned aborting At some point we changed these functions to return errors instead of aborting.
2022-03-17 17:23:22 -07:00
/// to show exactly how they are not equal, then returns a test failure error.
fix(text): hyphenation and other fixes
2022-10-03 19:52:39 +02:00
/// See `math.approxEqRel` for more information on the tolerance parameter.
/// The types must be floating-point.
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
/// `actual` and `expected` are coerced to a common type using peer type resolution.
pub inline fn expectApproxEqRel(expected: anytype, actual: anytype, tolerance: anytype) !void {
const T = @TypeOf(expected, actual, tolerance);
return expectApproxEqRelInner(T, expected, actual, tolerance);
}
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
fn expectApproxEqRelInner(comptime T: type, expected: T, actual: T, tolerance: T) !void {
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
switch (@typeInfo(T)) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedApproxEqRel;
},
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.comptime_float => @compileError("Cannot approximately compare two comptime_float values"),
Add expectWithinEpsilon + test
2020-06-23 18:08:15 +02:00
else => @compileError("Unable to compare non floating point values"),
}
}
std: promote tests to doctests Now these show up as "example usage" in generated documentation.
2024-03-13 15:56:09 -07:00
test expectApproxEqRel {
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
std.math: hard deprecate obsolete constants (soft deprecated in 0.10) Followup to 5b8ac9821dd25c3e5282130b4d93d6c5b7debb08. Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-04 23:09:17 +06:00
const eps_value = comptime math.floatEps(T);
compiler-rt: math functions reorg * unify the logic for exporting math functions from compiler-rt, with the appropriate suffixes and prefixes. - add all missing f128 and f80 exports. Functions with missing implementations call other functions and have TODO comments. - also add f16 functions * move math functions from freestanding libc to compiler-rt (#7265) * enable all the f128 and f80 code in the stage2 compiler and behavior tests (#11161). * update std lib to use builtins rather than `std.math`.
2022-04-26 10:13:55 -07:00
const sqrt_eps_value = comptime @sqrt(eps_value);
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
const pos_x: T = 12.0;
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
const pos_y: T = pos_x + 2 * eps_value;
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
const neg_x: T = -12.0;
std: Replace testing fns for floating-point values Beside handling NaNs and other non-numeric values better we finally offer the same pair of testing predicates in math and testing.
2021-03-13 13:08:46 +01:00
const neg_y: T = neg_x - 2 * eps_value;
Add expectWithinEpsilon + test
2020-06-23 18:08:15 +02:00
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectApproxEqRel(pos_x, pos_y, sqrt_eps_value);
try expectApproxEqRel(neg_x, neg_y, sqrt_eps_value);
std: Fix expectWithinEpsilon with negative values
2020-11-01 18:35:19 +01:00
}
Add expectWithinEpsilon + test
2020-06-23 18:08:15 +02:00
}
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
/// This function is intended to be used only in tests. When the two slices are not
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
/// equal, prints diagnostics to stderr to show exactly how they are not equal (with
/// the differences highlighted in red), then returns a test failure error.
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
/// The colorized output is optional and controlled by the return of `std.io.tty.detectConfig()`.
add std.testing.expectStringEndsWith
2020-12-08 21:54:46 -07:00
/// If your inputs are UTF-8 encoded strings, consider calling `expectEqualStrings` instead.
allow tests to fail
2021-05-04 19:36:59 +03:00
pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const T) !void {
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
if (expected.ptr == actual.ptr and expected.len == actual.len) {
return;
std.testing: Improve expectEqualBytes for large inputs and make expectEqualSlices use it `expectEqualBytes` will now truncate the hexdump of each input to a maximum window of 256 bytes, which makes it safe to use for arbitrarily large inputs. Therefore, it can be used in `expectEqualSlices` when the type is u8.
2022-11-30 18:06:02 -08:00
}
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
const diff_index: usize = diff_index: {
const shortest = @min(expected.len, actual.len);
var index: usize = 0;
while (index < shortest) : (index += 1) {
if (!std.meta.eql(actual[index], expected[index])) break :diff_index index;
}
break :diff_index if (expected.len == actual.len) return else shortest;
};
std.testing: disable expectEqualSlices printing for spirv
2023-10-08 21:00:20 +02:00
if (!backend_can_print) {
return error.TestExpectedEqual;
}
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
// TODO: Should this be configurable by the caller?
const max_lines: usize = 16;
const max_window_size: usize = if (T == u8) max_lines * 16 else max_lines;
// Print a maximum of max_window_size items of each input, starting just before the
// first difference to give a bit of context.
var window_start: usize = 0;
if (@max(actual.len, expected.len) > max_window_size) {
const alignment = if (T == u8) 16 else 2;
mem: rename align*Generic to mem.align* Anecdote 1: The generic version is way more popular than the non-generic one in Zig codebase: git grep -w alignForward | wc -l 56 git grep -w alignForwardGeneric | wc -l 149 git grep -w alignBackward | wc -l 6 git grep -w alignBackwardGeneric | wc -l 15 Anecdote 2: In my project (turbonss) that does much arithmetic and alignment I exclusively use the Generic functions. Anecdote 3: we used only the Generic versions in the Macho Man's linker workshop.
2023-06-09 16:02:18 -07:00
window_start = std.mem.alignBackward(usize, diff_index - @min(diff_index, alignment), alignment);
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
const expected_window = expected[window_start..@min(expected.len, window_start + max_window_size)];
const expected_truncated = window_start + expected_window.len < expected.len;
const actual_window = actual[window_start..@min(actual.len, window_start + max_window_size)];
const actual_truncated = window_start + actual_window.len < actual.len;
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
const stderr = std.io.getStdErr();
const ttyconf = std.io.tty.detectConfig(stderr);
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
var differ = if (T == u8) BytesDiffer{
.expected = expected_window,
.actual = actual_window,
.ttyconf = ttyconf,
} else SliceDiffer(T){
.start_index = window_start,
.expected = expected_window,
.actual = actual_window,
.ttyconf = ttyconf,
};
// Print indexes as hex for slices of u8 since it's more likely to be binary data where
// that is usually useful.
const index_fmt = if (T == u8) "0x{X}" else "{}";
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("\n============ expected this output: ============= len: {} (0x{X})\n\n", .{ expected.len, expected.len });
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
if (window_start > 0) {
if (T == u8) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated ...\n", .{});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
}
differ.write(stderr.writer()) catch {};
if (expected_truncated) {
const end_offset = window_start + expected_window.len;
const num_missing_items = expected.len - (window_start + expected_window.len);
if (T == u8) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
}
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
// now reverse expected/actual and print again
differ.expected = actual_window;
differ.actual = expected_window;
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("\n============= instead found this: ============== len: {} (0x{X})\n\n", .{ actual.len, actual.len });
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
if (window_start > 0) {
if (T == u8) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated ...\n", .{});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
}
differ.write(stderr.writer()) catch {};
if (actual_truncated) {
const end_offset = window_start + actual_window.len;
const num_missing_items = actual.len - (window_start + actual_window.len);
if (T == u8) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
}
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("\n================================================\n\n", .{});
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
return error.TestExpectedEqual;
}
fn SliceDiffer(comptime T: type) type {
return struct {
start_index: usize,
expected: []const T,
actual: []const T,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
ttyconf: std.io.tty.Config,
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
const Self = @This();
pub fn write(self: Self, writer: anytype) !void {
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (self.expected, 0..) |value, i| {
lib: correct unnecessary uses of 'var'
2023-11-10 05:27:17 +00:00
const full_index = self.start_index + i;
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
const diff = if (i < self.actual.len) !std.meta.eql(self.actual[i], value) else true;
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
if (diff) try self.ttyconf.setColor(writer, .red);
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
if (@typeInfo(T) == .pointer) {
std.testing.expectEqualSlices: On failure, print address for pointer types When comparing slice elements, `std.meta.eql` is used which only compares pointer address and length to determine equality for pointer types. This previously led to confusing results where `expectEqualSlices` would appear to fail on seemingly equal slices (judging by the output of `expectEqualSlices`. For example: try testing.expectEqualSlices( []const i64, &[_][]const i64{ &[_]i64{ 1, 2, 3 }, &[_]i64{ 5, 5, 5 } }, &[_][]const i64{ &[_]i64{ 1, 2, 3 }, &[_]i64{ 5, 5, 5 } }, ); Previously, this would result in: ============ expected this output: ============= len: 2 (0x2) [0]: { 1, 2, 3 } [1]: { 5, 5, 5 } ============= instead found this: ============== len: 2 (0x2) [0]: { 1, 2, 3 } [1]: { 5, 5, 5 } ================================================ After this commit, it will result in: ============ expected this output: ============= len: 2 (0x2) [0]i64@7ff7e2773758: { 1, 2, 3 } [1]i64@7ff7e2773770: { 5, 5, 5 } ============= instead found this: ============== len: 2 (0x2) [0]i64@7ff7e2773788: { 1, 2, 3 } [1]i64@7ff7e27737a0: { 5, 5, 5 } ================================================
2023-08-04 18:00:52 -07:00
try writer.print("[{}]{*}: {any}\n", .{ full_index, value, value });
} else {
try writer.print("[{}]: {any}\n", .{ full_index, value });
}
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
if (diff) try self.ttyconf.setColor(writer, .reset);
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
}
};
}
const BytesDiffer = struct {
expected: []const u8,
actual: []const u8,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
ttyconf: std.io.tty.Config,
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
pub fn write(self: BytesDiffer, writer: anytype) !void {
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
var expected_iterator = std.mem.window(u8, self.expected, 16, 16);
var row: usize = 0;
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
while (expected_iterator.next()) |chunk| {
// to avoid having to calculate diffs twice per chunk
var diffs: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 };
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
for (chunk, 0..) |byte, col| {
const absolute_byte_index = col + row * 16;
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
const diff = if (absolute_byte_index < self.actual.len) self.actual[absolute_byte_index] != byte else true;
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
if (diff) diffs.set(col);
try self.writeDiff(writer, "{X:0>2} ", .{byte}, diff);
if (col == 7) try writer.writeByte(' ');
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
try writer.writeByte(' ');
if (chunk.len < 16) {
var missing_columns = (16 - chunk.len) * 3;
if (chunk.len < 8) missing_columns += 1;
try writer.writeByteNTimes(' ', missing_columns);
}
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
for (chunk, 0..) |byte, col| {
const diff = diffs.isSet(col);
if (std.ascii.isPrint(byte)) {
try self.writeDiff(writer, "{c}", .{byte}, diff);
} else {
// TODO: remove this `if` when https://github.com/ziglang/zig/issues/7600 is fixed
if (self.ttyconf == .windows_api) {
try self.writeDiff(writer, ".", .{}, diff);
continue;
}
// Let's print some common control codes as graphical Unicode symbols.
// We don't want to do this for all control codes because most control codes apart from
// the ones that Zig has escape sequences for are likely not very useful to print as symbols.
switch (byte) {
'\n' => try self.writeDiff(writer, "␊", .{}, diff),
'\r' => try self.writeDiff(writer, "␍", .{}, diff),
'\t' => try self.writeDiff(writer, "␉", .{}, diff),
else => try self.writeDiff(writer, ".", .{}, diff),
}
}
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
try writer.writeByte('\n');
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
row += 1;
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
}
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
fn writeDiff(self: BytesDiffer, writer: anytype, comptime fmt: []const u8, args: anytype, diff: bool) !void {
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
if (diff) try self.ttyconf.setColor(writer, .red);
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
try writer.print(fmt, args);
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
if (diff) try self.ttyconf.setColor(writer, .reset);
std.testing: Fully absorb expectEqualBytes into expectEqualSlices - In #13720, expectEqualBytes was added as a standalone function - In #13723, expectEqualSlices was made to use expectEqualBytes when the type was u8 - In this commit, expectEqualSlices has fully absorbed expectEqualBytes, and expectEqualBytes itself has been removed For non-`u8` types, expectEqualSlices will now work similarly to expectEqualBytes (highlighting diffs in red), but will use a full line for each index and therefore will only print a maximum of 16 indexes.
2022-12-07 22:50:32 -08:00
}
};
test {
try expectEqualSlices(u8, "foo\x00", "foo\x00");
try expectEqualSlices(u16, &[_]u16{ 100, 200, 300, 400 }, &[_]u16{ 100, 200, 300, 400 });
const E = enum { foo, bar };
const S = struct {
v: E,
};
try expectEqualSlices(
S,
&[_]S{ .{ .v = .foo }, .{ .v = .bar }, .{ .v = .foo }, .{ .v = .bar } },
&[_]S{ .{ .v = .foo }, .{ .v = .bar }, .{ .v = .foo }, .{ .v = .bar } },
);
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
/// This function is intended to be used only in tests. Checks that two slices or two arrays are equal,
/// including that their sentinel (if any) are the same. Will error if given another type.
pub fn expectEqualSentinel(comptime T: type, comptime sentinel: T, expected: [:sentinel]const T, actual: [:sentinel]const T) !void {
try expectEqualSlices(T, expected, actual);
const expected_value_sentinel = blk: {
switch (@typeInfo(@TypeOf(expected))) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.pointer => {
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
break :blk expected[expected.len];
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.array => |array_info| {
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
const indexable_outside_of_bounds = @as([]const array_info.child, &expected);
break :blk indexable_outside_of_bounds[indexable_outside_of_bounds.len];
},
else => {},
}
};
const actual_value_sentinel = blk: {
switch (@typeInfo(@TypeOf(actual))) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.pointer => {
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
break :blk actual[actual.len];
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.array => |array_info| {
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
const indexable_outside_of_bounds = @as([]const array_info.child, &actual);
break :blk indexable_outside_of_bounds[indexable_outside_of_bounds.len];
},
else => {},
}
};
if (!std.meta.eql(sentinel, expected_value_sentinel)) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
return error.TestExpectedEqual;
}
if (!std.meta.eql(sentinel, actual_value_sentinel)) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
std.json: correctly handle sentinel terminated slices
2022-03-08 10:43:13 -08:00
return error.TestExpectedEqual;
}
}
std.testing: fix incorrect docs that mentioned aborting At some point we changed these functions to return errors instead of aborting.
2022-03-17 17:23:22 -07:00
/// This function is intended to be used only in tests.
/// When `ok` is false, returns a test failure error.
allow tests to fail
2021-05-04 19:36:59 +03:00
pub fn expect(ok: bool) !void {
if (!ok) return error.TestUnexpectedResult;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
}
Fixes #3966
2019-12-22 06:37:25 +05:00
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
pub const TmpDir = struct {
dir: std.fs.Dir,
parent_dir: std.fs.Dir,
sub_path: [sub_path_len]u8,
const random_bytes_count = 12;
std/base64: cleanups & support url-safe and other non-padded variants This makes a few changes to the base64 codecs. * The padding character is optional. The common "URL-safe" variant, in particular, is generally not used with padding. This is also the case for password hashes, so having this will avoid code duplication with bcrypt, scrypt and other functions. * The URL-safe variant is added. Instead of having individual constants for each parameter of each variant, we are now grouping these in a struct. So, `standard_pad_char` just becomes `standard.pad_char`. * Types are not `snake_case`'d any more. So, `standard_encoder` becomes `standard.Encoder`, as it is a type. * Creating a decoder with ignored characters required the alphabet and padding. Now, `standard.decoderWithIgnore(<ignored chars>)` returns a decoder with the standard parameters and the set of ignored chars. * Whatever applies to `standard.*` obviously also works with `url_safe.*` * the `calcSize()` interface was inconsistent, taking a length in the encoder, and a slice in the encoder. Rename the variant that takes a slice to `calcSizeForSlice()`. * In the decoder with ignored characters, add `calcSizeUpperBound()`, which is more useful than the one that takes a slice in order to size a fixed buffer before we have the data. * Return `error.InvalidCharacter` when the input actually contains characters that are neither padding nor part of the alphabet. If we hit a padding issue (which includes extra bits at the end), consistently return `error.InvalidPadding`. * Don't keep the `char_in_alphabet` array permanently in a decoder; it is only required for sanity checks during initialization. * Tests are unchanged, but now cover both the standard (padded) and the url-safe (non-padded) variants. * Add an error set, rename `OutputTooSmallError` to `NoSpaceLeft` to match the `hex2bin` equivalent.
2021-03-19 19:26:30 +01:00
const sub_path_len = std.fs.base64_encoder.calcSize(random_bytes_count);
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
pub fn cleanup(self: *TmpDir) void {
self.dir.close();
self.parent_dir.deleteTree(&self.sub_path) catch {};
self.parent_dir.close();
self.* = undefined;
}
};
std.fs.Dir: Rename OpenDirOptions to OpenOptions (#20542) * std.fs.Dir: Rename OpenDirOptions to OpenOptions https://ziglang.org/documentation/master/#Avoid-Redundant-Names-in-Fully-Qualified-Namespaces * std.fs.Dir: Add deprecated alias `OpenDirOptions`
2024-07-09 22:36:38 +02:00
pub fn tmpDir(opts: std.fs.Dir.OpenOptions) TmpDir {
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
var random_bytes: [TmpDir.random_bytes_count]u8 = undefined;
std: introduce a thread-local CSPRNG for general use std.crypto.random * cross platform, even freestanding * can't fail. on initialization for some systems requires calling os.getrandom(), in which case there are rare but theoretically possible errors. The code panics in these cases, however the application may choose to override the default seed function and then handle the failure another way. * thread-safe * supports the full Random interface * cryptographically secure * no syscall required to initialize on Linux (AT_RANDOM) * calls arc4random on systems that support it `std.crypto.randomBytes` is removed in favor of `std.crypto.random.bytes`. I moved some of the Random implementations into their own files in the interest of organization. stage2 no longer requires passing a RNG; instead it uses this API. Closes #6704
2020-12-17 20:03:41 -07:00
std.crypto.random.bytes(&random_bytes);
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
var sub_path: [TmpDir.sub_path_len]u8 = undefined;
Return encoded slice from base64 encode
2020-11-16 09:38:32 -05:00
_ = std.fs.base64_encoder.encode(&sub_path, &random_bytes);
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
lib: correct unnecessary uses of 'var'
2023-11-10 05:27:17 +00:00
const cwd = std.fs.cwd();
rename zig-cache to .zig-cache closes #20077
2024-05-29 10:20:15 -07:00
var cache_dir = cwd.makeOpenPath(".zig-cache", .{}) catch
@panic("unable to make tmp dir for testing: unable to make and open .zig-cache dir");
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
defer cache_dir.close();
lib: correct unnecessary uses of 'var'
2023-11-10 05:27:17 +00:00
const parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch
rename zig-cache to .zig-cache closes #20077
2024-05-29 10:20:15 -07:00
@panic("unable to make tmp dir for testing: unable to make and open .zig-cache/tmp dir");
lib: correct unnecessary uses of 'var'
2023-11-10 05:27:17 +00:00
const dir = parent_dir.makeOpenPath(&sub_path, opts) catch
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
@panic("unable to make tmp dir for testing: unable to make and open the tmp dir");
return .{
.dir = dir,
.parent_dir = parent_dir,
.sub_path = sub_path,
};
}
allow tests to fail
2021-05-04 19:36:59 +03:00
pub fn expectEqualStrings(expected: []const u8, actual: []const u8) !void {
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
if (std.mem.indexOfDiff(u8, actual, expected)) |diff_index| {
std: introduce GeneralPurposeAllocator `std.GeneralPurposeAllocator` is now available. It is a function that takes a configuration struct (with default field values) and returns an allocator. There is a detailed description of this allocator in the doc comments at the top of the new file. The main feature of this allocator is that it is *safe*. It prevents double-free, use-after-free, and detects leaks. Some deprecation compile errors are removed. The Allocator interface gains `old_align` as a new parameter to `resizeFn`. This is useful to quickly look up allocations. `std.heap.page_allocator` is improved to use mmap address hints to avoid obtaining the same virtual address pages when unmapping and mapping pages. The new general purpose allocator uses the page allocator as its backing allocator by default. `std.testing.allocator` is replaced with usage of this new allocator, which does leak checking, and so the LeakCheckAllocator is retired. stage1 is improved so that the `@typeInfo` of a pointer has a lazy value for the alignment of the child type, to avoid false dependency loops when dealing with pointers to async function frames. The `std.mem.Allocator` interface is refactored to be in its own file. `std.Mutex` now exposes the dummy mutex with `std.Mutex.Dummy`. This allocator is great for debug mode, however it needs some work to have better performance in release modes. The next step will be setting up a series of tests in ziglang/gotta-go-fast and then making improvements to the implementation.
2020-08-07 22:35:15 -07:00
print("\n====== expected this output: =========\n", .{});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
printWithVisibleNewlines(expected);
std: introduce GeneralPurposeAllocator `std.GeneralPurposeAllocator` is now available. It is a function that takes a configuration struct (with default field values) and returns an allocator. There is a detailed description of this allocator in the doc comments at the top of the new file. The main feature of this allocator is that it is *safe*. It prevents double-free, use-after-free, and detects leaks. Some deprecation compile errors are removed. The Allocator interface gains `old_align` as a new parameter to `resizeFn`. This is useful to quickly look up allocations. `std.heap.page_allocator` is improved to use mmap address hints to avoid obtaining the same virtual address pages when unmapping and mapping pages. The new general purpose allocator uses the page allocator as its backing allocator by default. `std.testing.allocator` is replaced with usage of this new allocator, which does leak checking, and so the LeakCheckAllocator is retired. stage1 is improved so that the `@typeInfo` of a pointer has a lazy value for the alignment of the child type, to avoid false dependency loops when dealing with pointers to async function frames. The `std.mem.Allocator` interface is refactored to be in its own file. `std.Mutex` now exposes the dummy mutex with `std.Mutex.Dummy`. This allocator is great for debug mode, however it needs some work to have better performance in release modes. The next step will be setting up a series of tests in ziglang/gotta-go-fast and then making improvements to the implementation.
2020-08-07 22:35:15 -07:00
print("\n======== instead found this: =========\n", .{});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
printWithVisibleNewlines(actual);
std: introduce GeneralPurposeAllocator `std.GeneralPurposeAllocator` is now available. It is a function that takes a configuration struct (with default field values) and returns an allocator. There is a detailed description of this allocator in the doc comments at the top of the new file. The main feature of this allocator is that it is *safe*. It prevents double-free, use-after-free, and detects leaks. Some deprecation compile errors are removed. The Allocator interface gains `old_align` as a new parameter to `resizeFn`. This is useful to quickly look up allocations. `std.heap.page_allocator` is improved to use mmap address hints to avoid obtaining the same virtual address pages when unmapping and mapping pages. The new general purpose allocator uses the page allocator as its backing allocator by default. `std.testing.allocator` is replaced with usage of this new allocator, which does leak checking, and so the LeakCheckAllocator is retired. stage1 is improved so that the `@typeInfo` of a pointer has a lazy value for the alignment of the child type, to avoid false dependency loops when dealing with pointers to async function frames. The `std.mem.Allocator` interface is refactored to be in its own file. `std.Mutex` now exposes the dummy mutex with `std.Mutex.Dummy`. This allocator is great for debug mode, however it needs some work to have better performance in release modes. The next step will be setting up a series of tests in ziglang/gotta-go-fast and then making improvements to the implementation.
2020-08-07 22:35:15 -07:00
print("\n======================================\n", .{});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
var diff_line_number: usize = 1;
for (expected[0..diff_index]) |value| {
if (value == '\n') diff_line_number += 1;
}
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
print("First difference occurs on line {d}:\n", .{diff_line_number});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
std: introduce GeneralPurposeAllocator `std.GeneralPurposeAllocator` is now available. It is a function that takes a configuration struct (with default field values) and returns an allocator. There is a detailed description of this allocator in the doc comments at the top of the new file. The main feature of this allocator is that it is *safe*. It prevents double-free, use-after-free, and detects leaks. Some deprecation compile errors are removed. The Allocator interface gains `old_align` as a new parameter to `resizeFn`. This is useful to quickly look up allocations. `std.heap.page_allocator` is improved to use mmap address hints to avoid obtaining the same virtual address pages when unmapping and mapping pages. The new general purpose allocator uses the page allocator as its backing allocator by default. `std.testing.allocator` is replaced with usage of this new allocator, which does leak checking, and so the LeakCheckAllocator is retired. stage1 is improved so that the `@typeInfo` of a pointer has a lazy value for the alignment of the child type, to avoid false dependency loops when dealing with pointers to async function frames. The `std.mem.Allocator` interface is refactored to be in its own file. `std.Mutex` now exposes the dummy mutex with `std.Mutex.Dummy`. This allocator is great for debug mode, however it needs some work to have better performance in release modes. The next step will be setting up a series of tests in ziglang/gotta-go-fast and then making improvements to the implementation.
2020-08-07 22:35:15 -07:00
print("expected:\n", .{});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
printIndicatorLine(expected, diff_index);
std: introduce GeneralPurposeAllocator `std.GeneralPurposeAllocator` is now available. It is a function that takes a configuration struct (with default field values) and returns an allocator. There is a detailed description of this allocator in the doc comments at the top of the new file. The main feature of this allocator is that it is *safe*. It prevents double-free, use-after-free, and detects leaks. Some deprecation compile errors are removed. The Allocator interface gains `old_align` as a new parameter to `resizeFn`. This is useful to quickly look up allocations. `std.heap.page_allocator` is improved to use mmap address hints to avoid obtaining the same virtual address pages when unmapping and mapping pages. The new general purpose allocator uses the page allocator as its backing allocator by default. `std.testing.allocator` is replaced with usage of this new allocator, which does leak checking, and so the LeakCheckAllocator is retired. stage1 is improved so that the `@typeInfo` of a pointer has a lazy value for the alignment of the child type, to avoid false dependency loops when dealing with pointers to async function frames. The `std.mem.Allocator` interface is refactored to be in its own file. `std.Mutex` now exposes the dummy mutex with `std.Mutex.Dummy`. This allocator is great for debug mode, however it needs some work to have better performance in release modes. The next step will be setting up a series of tests in ziglang/gotta-go-fast and then making improvements to the implementation.
2020-08-07 22:35:15 -07:00
print("found:\n", .{});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
printIndicatorLine(actual, diff_index);
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEqual;
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
}
stage2: improve `@typeName` * make it always return a fully qualified name. stage1 is inconsistent about this. * AstGen: fix anon_name_strategy to correctly be `func` when anon type creation happens in the operand of the return expression. * Sema: implement type names for the "function" naming strategy. * Put "enum", "union", "opaque", or "struct" in place of "anon" when creating respective anonymous Decl names. * std.testing: add `expectStringStartsWith`. Didn't end up using it after all. Also this enables the real test runner for stage2 LLVM backend (sans wasm32) since it works now.
2022-03-18 00:12:22 -07:00
pub fn expectStringStartsWith(actual: []const u8, expected_starts_with: []const u8) !void {
if (std.mem.startsWith(u8, actual, expected_starts_with))
return;
const shortened_actual = if (actual.len >= expected_starts_with.len)
actual[0..expected_starts_with.len]
else
actual;
print("\n====== expected to start with: =========\n", .{});
printWithVisibleNewlines(expected_starts_with);
testing: fix copy paste typo
2022-09-28 23:02:49 -04:00
print("\n====== instead started with: ===========\n", .{});
stage2: improve `@typeName` * make it always return a fully qualified name. stage1 is inconsistent about this. * AstGen: fix anon_name_strategy to correctly be `func` when anon type creation happens in the operand of the return expression. * Sema: implement type names for the "function" naming strategy. * Put "enum", "union", "opaque", or "struct" in place of "anon" when creating respective anonymous Decl names. * std.testing: add `expectStringStartsWith`. Didn't end up using it after all. Also this enables the real test runner for stage2 LLVM backend (sans wasm32) since it works now.
2022-03-18 00:12:22 -07:00
printWithVisibleNewlines(shortened_actual);
print("\n========= full output: ==============\n", .{});
printWithVisibleNewlines(actual);
print("\n======================================\n", .{});
return error.TestExpectedStartsWith;
}
allow tests to fail
2021-05-04 19:36:59 +03:00
pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8) !void {
add std.testing.expectStringEndsWith
2020-12-08 21:54:46 -07:00
if (std.mem.endsWith(u8, actual, expected_ends_with))
return;
const shortened_actual = if (actual.len >= expected_ends_with.len)
fix expectStringEndsWith error output. before it started outputting the actual starting, not ending characters.
2021-10-29 00:00:50 +02:00
actual[(actual.len - expected_ends_with.len)..]
add std.testing.expectStringEndsWith
2020-12-08 21:54:46 -07:00
else
actual;
print("\n====== expected to end with: =========\n", .{});
printWithVisibleNewlines(expected_ends_with);
print("\n====== instead ended with: ===========\n", .{});
printWithVisibleNewlines(shortened_actual);
print("\n========= full output: ==============\n", .{});
printWithVisibleNewlines(actual);
print("\n======================================\n", .{});
allow tests to fail
2021-05-04 19:36:59 +03:00
return error.TestExpectedEndsWith;
add std.testing.expectStringEndsWith
2020-12-08 21:54:46 -07:00
}
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
/// This function is intended to be used only in tests. When the two values are not
/// deeply equal, prints diagnostics to stderr to show exactly how they are not equal,
/// then returns a test failure error.
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
/// `actual` and `expected` are coerced to a common type using peer type resolution.
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
///
/// Deeply equal is defined as follows:
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
/// Primitive types are deeply equal if they are equal using `==` operator.
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
/// Struct values are deeply equal if their corresponding fields are deeply equal.
/// Container types(like Array/Slice/Vector) deeply equal when their corresponding elements are deeply equal.
/// Pointer values are deeply equal if values they point to are deeply equal.
///
std.testing: expectEqualDeep() - support self-referential structs
2023-09-23 13:25:57 -07:00
/// Note: Self-referential structs are supported (e.g. things like std.SinglyLinkedList)
/// but may cause infinite recursion or stack overflow when a container has a pointer to itself.
Update `std.testing.expectEqual` and friends to use peer type resolution This commit changes the type of the second parameter to `anytype`, which should make it easier to pass literals to these functions. This change shouldn't *silently* break existing code (the assertions themselves should retain the same behavior as before) but it may result in some new compile errors when struct/union/array literals or builtins like `@bitCast` are used for the second argument. These compile errors can be fixed by explicitly coercing these expressions to the correct type using `@as`.
2023-10-07 21:53:10 +02:00
pub inline fn expectEqualDeep(expected: anytype, actual: anytype) error{TestExpectedEqual}!void {
const T = @TypeOf(expected, actual);
return expectEqualDeepInner(T, expected, actual);
}
fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpectedEqual}!void {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
switch (@typeInfo(@TypeOf(actual))) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.noreturn,
.@"opaque",
.frame,
.@"anyframe",
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
=> @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.undefined,
.null,
.void,
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
=> return,
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.type => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.bool,
.int,
.float,
.comptime_float,
.comptime_int,
.enum_literal,
.@"enum",
.@"fn",
.error_set,
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
=> {
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {}, found {}\n", .{ expected, actual });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.pointer => |pointer| {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
switch (pointer.size) {
// We have no idea what is behind those pointers, so the best we can do is `==` check.
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
.c, .many => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {*}, found {*}\n", .{ expected, actual });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
},
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
.one => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
// Length of those pointers are runtime value, so the best we can do is `==` check.
switch (@typeInfo(pointer.child)) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"fn", .@"opaque" => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (actual != expected) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {*}, found {*}\n", .{ expected, actual });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
},
else => try expectEqualDeep(expected.*, actual.*),
}
},
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
.slice => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (expected.len != actual.len) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("Slice len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
var i: usize = 0;
while (i < expected.len) : (i += 1) {
expectEqualDeep(expected[i], actual[i]) catch |e| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("index {d} incorrect. expected {any}, found {any}\n", .{
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
i, expected[i], actual[i],
});
return e;
};
}
},
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.array => |_| {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (expected.len != actual.len) {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
var i: usize = 0;
while (i < expected.len) : (i += 1) {
expectEqualDeep(expected[i], actual[i]) catch |e| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("index {d} incorrect. expected {any}, found {any}\n", .{
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
i, expected[i], actual[i],
});
return e;
};
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.vector => |info| {
if (info.len != @typeInfo(@TypeOf(actual)).vector.len) {
print("Vector len not the same, expected {d}, found {d}\n", .{ info.len, @typeInfo(@TypeOf(actual)).vector.len });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
var i: usize = 0;
while (i < info.len) : (i += 1) {
expectEqualDeep(expected[i], actual[i]) catch |e| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("index {d} incorrect. expected {any}, found {any}\n", .{
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
i, expected[i], actual[i],
});
return e;
};
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"struct" => |structType| {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
inline for (structType.fields) |field| {
expectEqualDeep(@field(expected, field.name), @field(actual, field.name)) catch |e| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return e;
};
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"union" => |union_info| {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (union_info.tag_type == null) {
std.testing: improve compile error on untagged union equality
2025-02-10 23:05:38 -05:00
@compileError("Unable to compare untagged union values for type " ++ @typeName(@TypeOf(actual)));
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
}
const Tag = std.meta.Tag(@TypeOf(expected));
const expectedTag = @as(Tag, expected);
const actualTag = @as(Tag, actual);
try expectEqual(expectedTag, actualTag);
fix std.testing.expectEqual for comptime-only union switch from `inline for` with `std.mem.eql` to `inline else` and tag comparison; expectEqualDeep(Inner) was already doing this. add a previously-failing test case.
2024-06-18 19:01:05 +02:00
// we only reach this switch if the tags are equal
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
switch (expected) {
inline else => |val, tag| {
try expectEqualDeep(val, @field(actual, @tagName(tag)));
},
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.optional => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (expected) |expected_payload| {
if (actual) |actual_payload| {
try expectEqualDeep(expected_payload, actual_payload);
} else {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {any}, found null\n", .{expected_payload});
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
} else {
if (actual) |actual_payload| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected null, found {any}\n", .{actual_payload});
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
}
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.error_union => {
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
if (expected) |expected_payload| {
if (actual) |actual_payload| {
try expectEqualDeep(expected_payload, actual_payload);
} else |actual_err| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {any}, found {any}\n", .{ expected_payload, actual_err });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
}
} else |expected_err| {
if (actual) |actual_payload| {
testing: disable printing for targets that do not support it The SPIR-V cannot print the helpful error messages from the std.testing module. This commit overrides the default print function used here to one that only prints if the target supports it. For now, its only done for SPIR-V, but this function could be adapted to more targets that need it.
2023-07-01 14:29:11 +02:00
print("expected {any}, found {any}\n", .{ expected_err, actual_payload });
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
return error.TestExpectedEqual;
} else |actual_err| {
try expectEqualDeep(expected_err, actual_err);
}
}
},
}
}
test "expectEqualDeep primitive type" {
try expectEqualDeep(1, 1);
try expectEqualDeep(true, true);
try expectEqualDeep(1.5, 1.5);
try expectEqualDeep(u8, u8);
try expectEqualDeep(error.Bad, error.Bad);
// optional
{
const foo: ?u32 = 1;
const bar: ?u32 = 1;
try expectEqualDeep(foo, bar);
try expectEqualDeep(?u32, ?u32);
}
// function type
{
const fnType = struct {
fn foo() void {
unreachable;
}
}.foo;
try expectEqualDeep(fnType, fnType);
}
}
test "expectEqualDeep pointer" {
const a = 1;
const b = 1;
try expectEqualDeep(&a, &b);
}
test "expectEqualDeep composite type" {
try expectEqualDeep("abc", "abc");
const s1: []const u8 = "abc";
const s2 = "abcd";
const s3: []const u8 = s2[0..3];
try expectEqualDeep(s1, s3);
const TestStruct = struct { s: []const u8 };
try expectEqualDeep(TestStruct{ .s = "abc" }, TestStruct{ .s = "abc" });
try expectEqualDeep([_][]const u8{ "a", "b", "c" }, [_][]const u8{ "a", "b", "c" });
// vector
Remove len parameter from splat in standard lib
2023-07-06 19:48:42 +02:00
try expectEqualDeep(@as(@Vector(4, u32), @splat(4)), @as(@Vector(4, u32), @splat(4)));
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
// nested array
{
const a = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
const b = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
try expectEqualDeep(a, b);
try expectEqualDeep(&a, &b);
}
added expectEqualDeep test coverage for issue 16625 (#22781)
2025-02-15 12:41:58 +10:00
// inferred union
const TestStruct2 = struct {
const A = union(enum) { b: B, c: C };
const B = struct {};
const C = struct { a: *const A };
};
const union1 = TestStruct2.A{ .b = .{} };
try expectEqualDeep(
TestStruct2.A{ .c = .{ .a = &union1 } },
TestStruct2.A{ .c = .{ .a = &union1 } },
);
std: add expectEqualDeep (#13995)
2023-01-30 06:00:14 +08:00
}
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
fn printIndicatorLine(source: []const u8, indicator_index: usize) void {
const line_begin_index = if (std.mem.lastIndexOfScalar(u8, source[0..indicator_index], '\n')) |line_begin|
line_begin + 1
else
0;
const line_end_index = if (std.mem.indexOfScalar(u8, source[indicator_index..], '\n')) |line_end|
(indicator_index + line_end)
else
source.len;
printLine(source[line_begin_index..line_end_index]);
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
for (line_begin_index..indicator_index) |_|
print(" ", .{});
std.testing: make the caret indicator line more helpful
2022-07-25 14:51:22 +02:00
if (indicator_index >= source.len)
print("^ (end of string)\n", .{})
else
print("^ ('\\x{x:0>2}')\n", .{source[indicator_index]});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
fn printWithVisibleNewlines(source: []const u8) void {
var i: usize = 0;
testing: Use indexOfScalar instead of indexOf
2021-04-09 10:36:05 +02:00
while (std.mem.indexOfScalar(u8, source[i..], '\n')) |nl| : (i += nl + 1) {
convert s[start..start+len] to s[start..][0..len]
2023-05-02 22:08:54 +10:00
printLine(source[i..][0..nl]);
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
print("{s}␃\n", .{source[i..]}); // End of Text symbol (ETX)
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
fn printLine(line: []const u8) void {
std.testing: fix a crash when printing diffs
2020-05-22 00:27:51 -04:00
if (line.len != 0) switch (line[line.len - 1]) {
std.testing.expectEqualSlices: some improvements This mainly replaces ChunkIterator with std.mem.window and also prints \n, \r, \t using Unicode symbols instead of periods because they're common non-printable characters. This same code exists in std.debug.hexdump. At some point maybe this code could be exposed through a public function. Then we could reuse the code in both places.
2023-08-03 09:42:04 +02:00
' ', '\t' => return print("{s}⏎\n", .{line}), // Return symbol
std.testing: fix a crash when printing diffs
2020-05-22 00:27:51 -04:00
else => {},
};
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
print("{s}\n", .{line});
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
std: Update `test ""` to `test` where it makes sense
2021-01-22 15:45:28 +01:00
test {
allow tests to fail
2021-05-04 19:36:59 +03:00
try expectEqualStrings("foo", "foo");
move printWithVisibleNewlines to testing.expectEqualStrings
2020-04-29 14:40:52 +03:00
}
std: move std.meta.refAllDecls to std.testing
2020-09-28 07:29:53 -06:00
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
/// Exhaustively check that allocation failures within `test_fn` are handled without
/// introducing memory leaks. If used with the `testing.allocator` as the `backing_allocator`,
/// it will also be able to detect double frees, etc (when runtime safety is enabled).
///
/// The provided `test_fn` must have a `std.mem.Allocator` as its first argument,
/// and must have a return type of `!void`. Any extra arguments of `test_fn` can
/// be provided via the `extra_args` tuple.
///
/// Any relevant state shared between runs of `test_fn` *must* be reset within `test_fn`.
///
/// The strategy employed is to:
/// - Run the test function once to get the total number of allocations.
/// - Then, iterate and run the function X more times, incrementing
/// the failing index each iteration (where X is the total number of
/// allocations determined previously)
///
checkAllAllocationFailures: add possibility of SwallowedOutOfMemoryError (split from NondeterministicMemoryUsage) Inducing failure but not getting OutOfMemory back is not as much of a problem as never inducing failure when it was expected to be induced, so treating them differently and allowing them to be handled differently by the caller is useful. For example, the current implementation of `std.HashMapUnmanaged.getOrPutContextAdapted` always tries to grow and then recovers from OutOfMemory by attempting a lookup of an existing key. If this function is used (i.e. from `std.BufMap.putMove`) with `checkAllAllocationFailures`, then we'd have previously triggered `error.NondeterministicMemoryUsage`, but the real cause is that `OutOfMemory` is being recovered from and so the error is being swallowed. The new error allows us to both understand what's happening easier and to catch it and ignore it if we're okay with the code we're testing handling `error.OutOfMemory` without always bubbling it up.
2022-06-23 17:20:24 -07:00
/// Expects that `test_fn` has a deterministic number of memory allocations:
/// - If an allocation was made to fail during a run of `test_fn`, but `test_fn`
/// didn't return `error.OutOfMemory`, then `error.SwallowedOutOfMemoryError`
/// is returned from `checkAllAllocationFailures`. You may want to ignore this
/// depending on whether or not the code you're testing includes some strategies
/// for recovering from `error.OutOfMemory`.
/// - If a run of `test_fn` with an expected allocation failure executes without
/// an allocation failure being induced, then `error.NondeterministicMemoryUsage`
/// is returned. This error means that there are allocation points that won't be
/// tested by the strategy this function employs (that is, there are sometimes more
/// points of allocation than the initial run of `test_fn` detects).
///
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
/// ---
///
checkAllAllocationFailures: add possibility of SwallowedOutOfMemoryError (split from NondeterministicMemoryUsage) Inducing failure but not getting OutOfMemory back is not as much of a problem as never inducing failure when it was expected to be induced, so treating them differently and allowing them to be handled differently by the caller is useful. For example, the current implementation of `std.HashMapUnmanaged.getOrPutContextAdapted` always tries to grow and then recovers from OutOfMemory by attempting a lookup of an existing key. If this function is used (i.e. from `std.BufMap.putMove`) with `checkAllAllocationFailures`, then we'd have previously triggered `error.NondeterministicMemoryUsage`, but the real cause is that `OutOfMemory` is being recovered from and so the error is being swallowed. The new error allows us to both understand what's happening easier and to catch it and ignore it if we're okay with the code we're testing handling `error.OutOfMemory` without always bubbling it up.
2022-06-23 17:20:24 -07:00
/// Here's an example using a simple test case that will cause a leak when the
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
/// allocation of `bar` fails (but will pass normally):
///
/// ```zig
/// test {
/// const length: usize = 10;
/// const allocator = std.testing.allocator;
/// var foo = try allocator.alloc(u8, length);
/// var bar = try allocator.alloc(u8, length);
///
/// allocator.free(foo);
/// allocator.free(bar);
/// }
/// ```
///
/// The test case can be converted to something that this function can use by
/// doing:
///
/// ```zig
/// fn testImpl(allocator: std.mem.Allocator, length: usize) !void {
/// var foo = try allocator.alloc(u8, length);
/// var bar = try allocator.alloc(u8, length);
///
/// allocator.free(foo);
/// allocator.free(bar);
/// }
///
/// test {
/// const length: usize = 10;
/// const allocator = std.testing.allocator;
/// try std.testing.checkAllAllocationFailures(allocator, testImpl, .{length});
/// }
/// ```
///
/// Running this test will show that `foo` is leaked when the allocation of
/// `bar` fails. The simplest fix, in this case, would be to use defer like so:
///
/// ```zig
/// fn testImpl(allocator: std.mem.Allocator, length: usize) !void {
/// var foo = try allocator.alloc(u8, length);
/// defer allocator.free(foo);
/// var bar = try allocator.alloc(u8, length);
/// defer allocator.free(bar);
/// }
/// ```
pub fn checkAllAllocationFailures(backing_allocator: std.mem.Allocator, comptime test_fn: anytype, extra_args: anytype) !void {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
switch (@typeInfo(@typeInfo(@TypeOf(test_fn)).@"fn".return_type.?)) {
.error_union => |info| {
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
if (info.payload != void) {
@compileError("Return type must be !void");
}
},
else => @compileError("Return type must be !void"),
}
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
if (@typeInfo(@TypeOf(extra_args)) != .@"struct") {
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
@compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(extra_args)));
}
const ArgsTuple = std.meta.ArgsTuple(@TypeOf(test_fn));
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
const fn_args_fields = @typeInfo(ArgsTuple).@"struct".fields;
std.builtin: rename Type.UnionField and Type.StructField's field_type to type
2022-12-13 22:30:06 +01:00
if (fn_args_fields.len == 0 or fn_args_fields[0].type != std.mem.Allocator) {
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
@compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
}
const expected_args_tuple_len = fn_args_fields.len - 1;
if (extra_args.len != expected_args_tuple_len) {
AstGen: make `@compileError` operand implicitly comptime This matches the language reference.
2022-12-04 15:03:32 +02:00
@compileError("The provided function expects " ++ std.fmt.comptimePrint("{d}", .{expected_args_tuple_len}) ++ " extra arguments, but the provided tuple contains " ++ std.fmt.comptimePrint("{d}", .{extra_args.len}));
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
}
// Setup the tuple that will actually be used with @call (we'll need to insert
// the failing allocator in field @"0" before each @call)
var args: ArgsTuple = undefined;
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
inline for (@typeInfo(@TypeOf(extra_args)).@"struct".fields, 0..) |field, i| {
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
const arg_i_str = comptime str: {
var str_buf: [100]u8 = undefined;
const args_i = i + 1;
const str_len = std.fmt.formatIntBuf(&str_buf, args_i, 10, .lower, .{});
break :str str_buf[0..str_len];
};
@field(args, arg_i_str) = @field(extra_args, field.name);
}
// Try it once with unlimited memory, make sure it works
const needed_alloc_count = x: {
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{});
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
args.@"0" = failing_allocator_inst.allocator();
update usages of `@call`
2022-12-12 15:32:37 +02:00
try @call(.auto, test_fn, args);
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
break :x failing_allocator_inst.alloc_index;
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
};
var fail_index: usize = 0;
while (fail_index < needed_alloc_count) : (fail_index += 1) {
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
var failing_allocator_inst = std.testing.FailingAllocator.init(backing_allocator, .{ .fail_index = fail_index });
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
args.@"0" = failing_allocator_inst.allocator();
update usages of `@call`
2022-12-12 15:32:37 +02:00
if (@call(.auto, test_fn, args)) |_| {
checkAllAllocationFailures: add possibility of SwallowedOutOfMemoryError (split from NondeterministicMemoryUsage) Inducing failure but not getting OutOfMemory back is not as much of a problem as never inducing failure when it was expected to be induced, so treating them differently and allowing them to be handled differently by the caller is useful. For example, the current implementation of `std.HashMapUnmanaged.getOrPutContextAdapted` always tries to grow and then recovers from OutOfMemory by attempting a lookup of an existing key. If this function is used (i.e. from `std.BufMap.putMove`) with `checkAllAllocationFailures`, then we'd have previously triggered `error.NondeterministicMemoryUsage`, but the real cause is that `OutOfMemory` is being recovered from and so the error is being swallowed. The new error allows us to both understand what's happening easier and to catch it and ignore it if we're okay with the code we're testing handling `error.OutOfMemory` without always bubbling it up.
2022-06-23 17:20:24 -07:00
if (failing_allocator_inst.has_induced_failure) {
return error.SwallowedOutOfMemoryError;
} else {
return error.NondeterministicMemoryUsage;
}
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
} else |err| switch (err) {
error.OutOfMemory => {
if (failing_allocator_inst.allocated_bytes != failing_allocator_inst.freed_bytes) {
print(
Make invalidFmtError public and use in place of compileErrors for bad format strings (#13526) * Export invalidFmtErr To allow consistent use of "invalid format string" compile error response for badly formatted format strings. See https://github.com/ziglang/zig/pull/13489#issuecomment-1311759340. * Replace format compile errors with invalidFmtErr - Provides more consistent compile errors. - Gives user info about the type of the badly formated value. * Rename invalidFmtErr as invalidFmtError For consistency. Zig seems to use “Error” more often than “Err”. * std: add invalid format string checks to remaining custom formatters * pass reference-trace to comp when building build file; fix checkobjectstep
2022-11-12 20:03:24 +01:00
"\nfail_index: {d}/{d}\nallocated bytes: {d}\nfreed bytes: {d}\nallocations: {d}\ndeallocations: {d}\nallocation that was made to fail: {}",
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
.{
fail_index,
needed_alloc_count,
failing_allocator_inst.allocated_bytes,
failing_allocator_inst.freed_bytes,
failing_allocator_inst.allocations,
failing_allocator_inst.deallocations,
Integrate FailingAllocator stack trace with testing.checkAllAllocationFailures
2022-06-23 17:02:29 -07:00
failing_allocator_inst.getStackTrace(),
Add `std.testing.checkAllAllocationFailures` Adds a function that allows checking for memory leaks (and other problems) by taking advantage of the FailingAllocator and inducing failure at every allocation point within the provided `test_fn` (based on the strategy employed in the Zig parser tests, which can now use this function).
2022-01-13 00:35:50 -08:00
},
);
return error.MemoryLeakDetected;
}
},
else => return err,
}
}
}
docs: minor improvements Just some minor improvements when passing by.
2022-09-29 09:43:22 +02:00
/// Given a type, references all the declarations inside, so that the semantic analyzer sees them.
std: move std.meta.refAllDecls to std.testing
2020-09-28 07:29:53 -06:00
pub fn refAllDecls(comptime T: type) void {
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
if (!builtin.is_test) return;
a small crusade against std.meta.declarations
2022-01-31 22:25:49 -07:00
inline for (comptime std.meta.declarations(T)) |decl| {
make `@typeInfo` not return private decls fixes #10731 Thanks @nektro for previous work in #14878 This change creates a small breaking change: It removes the `is_pub` field of a decl in `@typeInfo`
2023-07-25 11:15:59 -04:00
_ = &@field(T, decl.name);
std: move std.meta.refAllDecls to std.testing
2020-09-28 07:29:53 -06:00
}
}
std.testing: add `refAllDeclsRecursive` function
2022-07-13 18:46:10 +04:30
docs: minor improvements Just some minor improvements when passing by.
2022-09-29 09:43:22 +02:00
/// Given a type, recursively references all the declarations inside, so that the semantic analyzer sees them.
/// For deep types, you may use `@setEvalBranchQuota`.
std.testing: add `refAllDeclsRecursive` function
2022-07-13 18:46:10 +04:30
pub fn refAllDeclsRecursive(comptime T: type) void {
fix(std.testing.refAllDeclsRecursive): silently return if !builtin.is_test
2022-09-29 09:42:58 +02:00
if (!builtin.is_test) return;
std.testing: add `refAllDeclsRecursive` function
2022-07-13 18:46:10 +04:30
inline for (comptime std.meta.declarations(T)) |decl| {
make `@typeInfo` not return private decls fixes #10731 Thanks @nektro for previous work in #14878 This change creates a small breaking change: It removes the `is_pub` field of a decl in `@typeInfo`
2023-07-25 11:15:59 -04:00
if (@TypeOf(@field(T, decl.name)) == type) {
switch (@typeInfo(@field(T, decl.name))) {
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.@"struct", .@"enum", .@"union", .@"opaque" => refAllDeclsRecursive(@field(T, decl.name)),
make `@typeInfo` not return private decls fixes #10731 Thanks @nektro for previous work in #14878 This change creates a small breaking change: It removes the `is_pub` field of a decl in `@typeInfo`
2023-07-25 11:15:59 -04:00
else => {},
std.testing: add `refAllDeclsRecursive` function
2022-07-13 18:46:10 +04:30
}
}
make `@typeInfo` not return private decls fixes #10731 Thanks @nektro for previous work in #14878 This change creates a small breaking change: It removes the `is_pub` field of a decl in `@typeInfo`
2023-07-25 11:15:59 -04:00
_ = &@field(T, decl.name);
std.testing: add `refAllDeclsRecursive` function
2022-07-13 18:46:10 +04:30
}
}
implement std.testing.fuzzInput for the -fno-fuzz case. The other case will take more work in libfuzzer.
2024-07-22 16:45:19 -07:00
pub const FuzzInputOptions = struct {
corpus: []const []const u8 = &.{},
};
rework fuzzing API The previous API used `std.testing.fuzzInput(.{})` however that has the problem that users call it multiple times incorrectly, and there might be work happening to obtain the corpus which should not be included in coverage analysis, and which must not slow down iteration speed. This commit restructures it so that the main loop lives in libfuzzer and directly calls the "test one" function. In this commit I was a little too aggressive because I made the test runner export `fuzzer_one` for this purpose. This was motivated by performance, but it causes "exported symbol collision: fuzzer_one" to occur when more than one fuzz test is provided. There are three ways to solve this: 1. libfuzzer needs to be passed a function pointer instead. Possible performance downside. 2. build runner needs to build a different process per fuzz test. Potentially wasteful and unclear how to isolate them. 3. test runner needs to perform a relocation at runtime to point the function call to the relevant unit test. Portability issues and dubious performance gains.
2024-09-09 19:36:52 -07:00
/// Inline to avoid coverage instrumentation.
pub inline fn fuzz(
fuzzer: write inputs to shared memory before running breaking change to the fuzz testing API; it now passes a type-safe context parameter to the fuzz function. libfuzzer is reworked to select inputs from the entire corpus. I tested that it's roughly as good as it was before in that it can find the panics in the simple examples, as well as achieve decent coverage on the tokenizer fuzz test. however I think the next step here will be figuring out why so many points of interest are missing from the tokenizer in both Debug and ReleaseSafe modes. does not quite close #20803 yet since there are some more important things to be done, such as opening the previous corpus, continuing fuzzing after finding bugs, storing the length of the inputs, etc.
2025-02-11 11:54:12 -08:00
context: anytype,
comptime testOne: fn (context: @TypeOf(context), input: []const u8) anyerror!void,
rework fuzzing API The previous API used `std.testing.fuzzInput(.{})` however that has the problem that users call it multiple times incorrectly, and there might be work happening to obtain the corpus which should not be included in coverage analysis, and which must not slow down iteration speed. This commit restructures it so that the main loop lives in libfuzzer and directly calls the "test one" function. In this commit I was a little too aggressive because I made the test runner export `fuzzer_one` for this purpose. This was motivated by performance, but it causes "exported symbol collision: fuzzer_one" to occur when more than one fuzz test is provided. There are three ways to solve this: 1. libfuzzer needs to be passed a function pointer instead. Possible performance downside. 2. build runner needs to build a different process per fuzz test. Potentially wasteful and unclear how to isolate them. 3. test runner needs to perform a relocation at runtime to point the function call to the relevant unit test. Portability issues and dubious performance gains.
2024-09-09 19:36:52 -07:00
options: FuzzInputOptions,
) anyerror!void {
fuzzer: write inputs to shared memory before running breaking change to the fuzz testing API; it now passes a type-safe context parameter to the fuzz function. libfuzzer is reworked to select inputs from the entire corpus. I tested that it's roughly as good as it was before in that it can find the panics in the simple examples, as well as achieve decent coverage on the tokenizer fuzz test. however I think the next step here will be figuring out why so many points of interest are missing from the tokenizer in both Debug and ReleaseSafe modes. does not quite close #20803 yet since there are some more important things to be done, such as opening the previous corpus, continuing fuzzing after finding bugs, storing the length of the inputs, etc.
2025-02-11 11:54:12 -08:00
return @import("root").fuzz(context, testOne, options);
implement std.testing.fuzzInput for the -fno-fuzz case. The other case will take more work in libfuzzer.
2024-07-22 16:45:19 -07:00
}
Reference in New Issue Copy Permalink