authorgravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2023-07-01 14:29:11+02:00
committergravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2023-07-01 14:29:11+02:00
logaa398034eb1b2fd74e1815ae2e75ca1a3ca4a567
tree089f0f7f0a1ad1b6e304d22f83cf4d71c57c4561
parent74f40ddd11451707a046f2a8b0807a656f81b51c
signaturebadge-check Signed by SSH key SHA256:CQ99aPxq+RueiL9u7z0FEki5Fm7V6T8q4PrEGmINrA4

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.

1 files changed, 50 insertions(+), 44 deletions(-)

lib/std/testing.zig+50-44
......@@ -2,7 +2,6 @@ const std = @import("std.zig");
22const builtin = @import("builtin");
33
44const math = std.math;
5const print = std.debug.print;
65
76pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
87
......@@ -22,15 +21,22 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
2221/// TODO https://github.com/ziglang/zig/issues/5738
2322pub var log_level = std.log.Level.warn;
2423
24fn print(comptime fmt: []const u8, args: anytype) void {
25 // Disable printing in tests for simple backends.
26 if (builtin.zig_backend == .stage2_spirv64) return;
27
28 std.debug.print(fmt, args);
29}
30
2531/// This function is intended to be used only in tests. It prints diagnostics to stderr
2632/// and then returns a test failure error when actual_error_union is not expected_error.
2733pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
2834 if (actual_error_union) |actual_payload| {
29 std.debug.print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
35 print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
3036 return error.TestUnexpectedError;
3137 } else |actual_error| {
3238 if (expected_error != actual_error) {
33 std.debug.print("expected error.{s}, found error.{s}\n", .{
39 print("expected error.{s}, found error.{s}\n", .{
3440 @errorName(expected_error),
3541 @errorName(actual_error),
3642 });
......@@ -58,7 +64,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
5864
5965 .Type => {
6066 if (actual != expected) {
61 std.debug.print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
67 print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
6268 return error.TestExpectedEqual;
6369 }
6470 },
......@@ -74,7 +80,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
7480 .ErrorSet,
7581 => {
7682 if (actual != expected) {
77 std.debug.print("expected {}, found {}\n", .{ expected, actual });
83 print("expected {}, found {}\n", .{ expected, actual });
7884 return error.TestExpectedEqual;
7985 }
8086 },
......@@ -83,17 +89,17 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
8389 switch (pointer.size) {
8490 .One, .Many, .C => {
8591 if (actual != expected) {
86 std.debug.print("expected {*}, found {*}\n", .{ expected, actual });
92 print("expected {*}, found {*}\n", .{ expected, actual });
8793 return error.TestExpectedEqual;
8894 }
8995 },
9096 .Slice => {
9197 if (actual.ptr != expected.ptr) {
92 std.debug.print("expected slice ptr {*}, found {*}\n", .{ expected.ptr, actual.ptr });
98 print("expected slice ptr {*}, found {*}\n", .{ expected.ptr, actual.ptr });
9399 return error.TestExpectedEqual;
94100 }
95101 if (actual.len != expected.len) {
96 std.debug.print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
102 print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
97103 return error.TestExpectedEqual;
98104 }
99105 },
......@@ -106,7 +112,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
106112 var i: usize = 0;
107113 while (i < info.len) : (i += 1) {
108114 if (!std.meta.eql(expected[i], actual[i])) {
109 std.debug.print("index {} incorrect. expected {}, found {}\n", .{
115 print("index {} incorrect. expected {}, found {}\n", .{
110116 i, expected[i], actual[i],
111117 });
112118 return error.TestExpectedEqual;
......@@ -151,12 +157,12 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
151157 if (actual) |actual_payload| {
152158 try expectEqual(expected_payload, actual_payload);
153159 } else {
154 std.debug.print("expected {any}, found null\n", .{expected_payload});
160 print("expected {any}, found null\n", .{expected_payload});
155161 return error.TestExpectedEqual;
156162 }
157163 } else {
158164 if (actual) |actual_payload| {
159 std.debug.print("expected null, found {any}\n", .{actual_payload});
165 print("expected null, found {any}\n", .{actual_payload});
160166 return error.TestExpectedEqual;
161167 }
162168 }
......@@ -167,12 +173,12 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
167173 if (actual) |actual_payload| {
168174 try expectEqual(expected_payload, actual_payload);
169175 } else |actual_err| {
170 std.debug.print("expected {any}, found {}\n", .{ expected_payload, actual_err });
176 print("expected {any}, found {}\n", .{ expected_payload, actual_err });
171177 return error.TestExpectedEqual;
172178 }
173179 } else |expected_err| {
174180 if (actual) |actual_payload| {
175 std.debug.print("expected {}, found {any}\n", .{ expected_err, actual_payload });
181 print("expected {}, found {any}\n", .{ expected_err, actual_payload });
176182 return error.TestExpectedEqual;
177183 } else |actual_err| {
178184 try expectEqual(expected_err, actual_err);
......@@ -219,7 +225,7 @@ pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance
219225
220226 switch (@typeInfo(T)) {
221227 .Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
222 std.debug.print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
228 print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
223229 return error.TestExpectedApproxEqAbs;
224230 },
225231
......@@ -251,7 +257,7 @@ pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance
251257
252258 switch (@typeInfo(T)) {
253259 .Float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
254 std.debug.print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
260 print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
255261 return error.TestExpectedApproxEqRel;
256262 },
257263
......@@ -294,7 +300,7 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
294300 break :diff_index if (expected.len == actual.len) return else shortest;
295301 };
296302
297 std.debug.print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
303 print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
298304
299305 // TODO: Should this be configurable by the caller?
300306 const max_lines: usize = 16;
......@@ -329,12 +335,12 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
329335 // that is usually useful.
330336 const index_fmt = if (T == u8) "0x{X}" else "{}";
331337
332 std.debug.print("\n============ expected this output: ============= len: {} (0x{X})\n\n", .{ expected.len, expected.len });
338 print("\n============ expected this output: ============= len: {} (0x{X})\n\n", .{ expected.len, expected.len });
333339 if (window_start > 0) {
334340 if (T == u8) {
335 std.debug.print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
341 print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
336342 } else {
337 std.debug.print("... truncated ...\n", .{});
343 print("... truncated ...\n", .{});
338344 }
339345 }
340346 differ.write(stderr.writer()) catch {};
......@@ -342,21 +348,21 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
342348 const end_offset = window_start + expected_window.len;
343349 const num_missing_items = expected.len - (window_start + expected_window.len);
344350 if (T == u8) {
345 std.debug.print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
351 print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
346352 } else {
347 std.debug.print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
353 print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
348354 }
349355 }
350356
351357 // now reverse expected/actual and print again
352358 differ.expected = actual_window;
353359 differ.actual = expected_window;
354 std.debug.print("\n============= instead found this: ============== len: {} (0x{X})\n\n", .{ actual.len, actual.len });
360 print("\n============= instead found this: ============== len: {} (0x{X})\n\n", .{ actual.len, actual.len });
355361 if (window_start > 0) {
356362 if (T == u8) {
357 std.debug.print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
363 print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
358364 } else {
359 std.debug.print("... truncated ...\n", .{});
365 print("... truncated ...\n", .{});
360366 }
361367 }
362368 differ.write(stderr.writer()) catch {};
......@@ -364,12 +370,12 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
364370 const end_offset = window_start + actual_window.len;
365371 const num_missing_items = actual.len - (window_start + actual_window.len);
366372 if (T == u8) {
367 std.debug.print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
373 print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
368374 } else {
369 std.debug.print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
375 print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
370376 }
371377 }
372 std.debug.print("\n================================================\n\n", .{});
378 print("\n================================================\n\n", .{});
373379
374380 return error.TestExpectedEqual;
375381}
......@@ -493,12 +499,12 @@ pub fn expectEqualSentinel(comptime T: type, comptime sentinel: T, expected: [:s
493499 };
494500
495501 if (!std.meta.eql(sentinel, expected_value_sentinel)) {
496 std.debug.print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
502 print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
497503 return error.TestExpectedEqual;
498504 }
499505
500506 if (!std.meta.eql(sentinel, actual_value_sentinel)) {
501 std.debug.print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
507 print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
502508 return error.TestExpectedEqual;
503509 }
504510}
......@@ -697,7 +703,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
697703
698704 .Type => {
699705 if (actual != expected) {
700 std.debug.print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
706 print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
701707 return error.TestExpectedEqual;
702708 }
703709 },
......@@ -713,7 +719,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
713719 .ErrorSet,
714720 => {
715721 if (actual != expected) {
716 std.debug.print("expected {}, found {}\n", .{ expected, actual });
722 print("expected {}, found {}\n", .{ expected, actual });
717723 return error.TestExpectedEqual;
718724 }
719725 },
......@@ -723,7 +729,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
723729 // We have no idea what is behind those pointers, so the best we can do is `==` check.
724730 .C, .Many => {
725731 if (actual != expected) {
726 std.debug.print("expected {*}, found {*}\n", .{ expected, actual });
732 print("expected {*}, found {*}\n", .{ expected, actual });
727733 return error.TestExpectedEqual;
728734 }
729735 },
......@@ -732,7 +738,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
732738 switch (@typeInfo(pointer.child)) {
733739 .Fn, .Opaque => {
734740 if (actual != expected) {
735 std.debug.print("expected {*}, found {*}\n", .{ expected, actual });
741 print("expected {*}, found {*}\n", .{ expected, actual });
736742 return error.TestExpectedEqual;
737743 }
738744 },
......@@ -741,13 +747,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
741747 },
742748 .Slice => {
743749 if (expected.len != actual.len) {
744 std.debug.print("Slice len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
750 print("Slice len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
745751 return error.TestExpectedEqual;
746752 }
747753 var i: usize = 0;
748754 while (i < expected.len) : (i += 1) {
749755 expectEqualDeep(expected[i], actual[i]) catch |e| {
750 std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
756 print("index {d} incorrect. expected {any}, found {any}\n", .{
751757 i, expected[i], actual[i],
752758 });
753759 return e;
......@@ -759,13 +765,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
759765
760766 .Array => |_| {
761767 if (expected.len != actual.len) {
762 std.debug.print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
768 print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
763769 return error.TestExpectedEqual;
764770 }
765771 var i: usize = 0;
766772 while (i < expected.len) : (i += 1) {
767773 expectEqualDeep(expected[i], actual[i]) catch |e| {
768 std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
774 print("index {d} incorrect. expected {any}, found {any}\n", .{
769775 i, expected[i], actual[i],
770776 });
771777 return e;
......@@ -775,13 +781,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
775781
776782 .Vector => |info| {
777783 if (info.len != @typeInfo(@TypeOf(actual)).Vector.len) {
778 std.debug.print("Vector len not the same, expected {d}, found {d}\n", .{ info.len, @typeInfo(@TypeOf(actual)).Vector.len });
784 print("Vector len not the same, expected {d}, found {d}\n", .{ info.len, @typeInfo(@TypeOf(actual)).Vector.len });
779785 return error.TestExpectedEqual;
780786 }
781787 var i: usize = 0;
782788 while (i < info.len) : (i += 1) {
783789 expectEqualDeep(expected[i], actual[i]) catch |e| {
784 std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
790 print("index {d} incorrect. expected {any}, found {any}\n", .{
785791 i, expected[i], actual[i],
786792 });
787793 return e;
......@@ -792,7 +798,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
792798 .Struct => |structType| {
793799 inline for (structType.fields) |field| {
794800 expectEqualDeep(@field(expected, field.name), @field(actual, field.name)) catch |e| {
795 std.debug.print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
801 print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
796802 return e;
797803 };
798804 }
......@@ -823,12 +829,12 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
823829 if (actual) |actual_payload| {
824830 try expectEqualDeep(expected_payload, actual_payload);
825831 } else {
826 std.debug.print("expected {any}, found null\n", .{expected_payload});
832 print("expected {any}, found null\n", .{expected_payload});
827833 return error.TestExpectedEqual;
828834 }
829835 } else {
830836 if (actual) |actual_payload| {
831 std.debug.print("expected null, found {any}\n", .{actual_payload});
837 print("expected null, found {any}\n", .{actual_payload});
832838 return error.TestExpectedEqual;
833839 }
834840 }
......@@ -839,12 +845,12 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
839845 if (actual) |actual_payload| {
840846 try expectEqualDeep(expected_payload, actual_payload);
841847 } else |actual_err| {
842 std.debug.print("expected {any}, found {any}\n", .{ expected_payload, actual_err });
848 print("expected {any}, found {any}\n", .{ expected_payload, actual_err });
843849 return error.TestExpectedEqual;
844850 }
845851 } else |expected_err| {
846852 if (actual) |actual_payload| {
847 std.debug.print("expected {any}, found {any}\n", .{ expected_err, actual_payload });
853 print("expected {any}, found {any}\n", .{ expected_err, actual_payload });
848854 return error.TestExpectedEqual;
849855 } else |actual_err| {
850856 try expectEqualDeep(expected_err, actual_err);