zig/mach
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

testing: use "eql", not "equal(s)"

Browse source 
This is more consistent with the stdlib everywhere other than `std.testing`.

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
This commit is contained in:
Stephen Gutekanst 2023-09-04 15:43:49 -07:00
parent 2781d4afd4
commit 6b5a9990b9
1 changed files with 28 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

56
src/testing.zig
View file

@ -9,17 +9,17 @@ fn ExpectFloat(comptime T: type) type {
expected: T, expected: T,
/// Approximate (absolute epsilon tolerence) equality /// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void { pub fn eql(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(T)); try e.eqlApprox(actual, math.eps(T));
} }
/// Approximate (tolerence) equality /// Approximate (tolerence) equality
pub fn equalApprox(e: *const @This(), actual: T, tolerance: T) !void { pub fn eqlApprox(e: *const @This(), actual: T, tolerance: T) !void {
try testing.expectApproxEqAbs(e.expected, actual, tolerance); try testing.expectApproxEqAbs(e.expected, actual, tolerance);
} }
/// Bitwise equality /// Bitwise equality
pub fn equalBinary(e: *const @This(), actual: T) !void { pub fn eqlBinary(e: *const @This(), actual: T) !void {
try testing.expectEqual(e.expected, actual); try testing.expectEqual(e.expected, actual);
} }
}; };
@ -32,15 +32,15 @@ fn ExpectVector(comptime T: type) type {
expected: T, expected: T,
/// Approximate (absolute epsilon tolerence) equality /// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void { pub fn eql(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(Elem)); try e.eqlApprox(actual, math.eps(Elem));
} }
/// Approximate (tolerence) equality /// Approximate (tolerence) equality
pub fn equalApprox(e: *const @This(), actual: T, tolerance: Elem) !void { pub fn eqlApprox(e: *const @This(), actual: T, tolerance: Elem) !void {
var i: usize = 0; var i: usize = 0;
while (i < len) : (i += 1) { while (i < len) : (i += 1) {
if (!math.equals(Elem, e.expected[i], actual[i], tolerance)) { if (!math.eql(Elem, e.expected[i], actual[i], tolerance)) {
std.debug.print("vector[{}] actual {}, not within absolute tolerance {} of expected {}\n", .{ i, actual[i], tolerance, e.expected[i] }); std.debug.print("vector[{}] actual {}, not within absolute tolerance {} of expected {}\n", .{ i, actual[i], tolerance, e.expected[i] });
return error.TestExpectEqualEps; return error.TestExpectEqualEps;
} }
@ -48,7 +48,7 @@ fn ExpectVector(comptime T: type) type {
} }
/// Bitwise equality /// Bitwise equality
pub fn equalBinary(e: *const @This(), actual: T) !void { pub fn eqlBinary(e: *const @This(), actual: T) !void {
try testing.expectEqual(e.expected, actual); try testing.expectEqual(e.expected, actual);
} }
}; };
@ -59,15 +59,15 @@ fn ExpectVecMat(comptime T: type) type {
expected: T, expected: T,
/// Approximate (absolute epsilon tolerence) equality /// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void { pub fn eql(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(T.T)); try e.eqlApprox(actual, math.eps(T.T));
} }
/// Approximate (tolerence) equality /// Approximate (tolerence) equality
pub fn equalApprox(e: *const @This(), actual: T, tolerance: T.T) !void { pub fn eqlApprox(e: *const @This(), actual: T, tolerance: T.T) !void {
var i: usize = 0; var i: usize = 0;
while (i < T.n) : (i += 1) { while (i < T.n) : (i += 1) {
if (!math.equals(T.T, e.expected.v[i], actual.v[i], tolerance)) { if (!math.eql(T.T, e.expected.v[i], actual.v[i], tolerance)) {
std.debug.print("vector[{}] actual {}, not within absolute tolerance {} of expected {}\n", .{ i, actual.v[i], tolerance, e.expected.v[i] }); std.debug.print("vector[{}] actual {}, not within absolute tolerance {} of expected {}\n", .{ i, actual.v[i], tolerance, e.expected.v[i] });
return error.TestExpectEqualEps; return error.TestExpectEqualEps;
} }
@ -75,7 +75,7 @@ fn ExpectVecMat(comptime T: type) type {
} }
/// Bitwise equality /// Bitwise equality
pub fn equalBinary(e: *const @This(), actual: T) !void { pub fn eqlBinary(e: *const @This(), actual: T) !void {
try testing.expectEqual(e.expected.v, actual.v); try testing.expectEqual(e.expected.v, actual.v);
} }
}; };
@ -84,7 +84,7 @@ fn ExpectVecMat(comptime T: type) type {
fn ExpectComptime(comptime T: type) type { fn ExpectComptime(comptime T: type) type {
return struct { return struct {
expected: T, expected: T,
pub fn equal(comptime e: *const @This(), comptime actual: T) !void { pub fn eql(comptime e: *const @This(), comptime actual: T) !void {
try testing.expectEqual(e.expected, actual); try testing.expectEqual(e.expected, actual);
} }
}; };
@ -94,11 +94,11 @@ fn ExpectBytes(comptime T: type) type {
return struct { return struct {
expected: T, expected: T,
pub fn equal(comptime e: *const @This(), comptime actual: T) !void { pub fn eql(comptime e: *const @This(), comptime actual: T) !void {
try testing.expectEqualStrings(e.expected, actual); try testing.expectEqualStrings(e.expected, actual);
} }
pub fn equalBinary(comptime e: *const @This(), comptime actual: T) !void { pub fn eqlBinary(comptime e: *const @This(), comptime actual: T) !void {
try testing.expectEqual(e.expected, actual); try testing.expectEqual(e.expected, actual);
} }
}; };
@ -119,7 +119,7 @@ fn Expect(comptime T: type) type {
// Generic equality // Generic equality
return struct { return struct {
expected: T, expected: T,
pub fn equal(e: *const @This(), actual: T) !void { pub fn eql(e: *const @This(), actual: T) !void {
try testing.expectEqual(e.expected, actual); try testing.expectEqual(e.expected, actual);
} }
}; };
@ -133,42 +133,42 @@ fn Expect(comptime T: type) type {
/// ///
/// Floats, mach.math.Vec, and mach.math.Mat types support: /// Floats, mach.math.Vec, and mach.math.Mat types support:
/// ///
/// * `.equal(v)` (epsilon equality) /// * `.eql(v)` (epsilon equality)
/// * `.equalApprox(v, tolerence)` (specific tolerence equality) /// * `.eqlApprox(v, tolerence)` (specific tolerence equality)
/// * `.equalBinary(v)` binary equality /// * `.eqlBinary(v)` binary equality
/// ///
/// All other types support only `.equal(v)` binary equality. /// All other types support only `.eql(v)` binary equality.
/// ///
/// Comparisons with std.testing: /// Comparisons with std.testing:
/// ///
/// ```diff /// ```diff
/// -std.testing.expectEqual(@as(u32, 1337), actual()) /// -std.testing.expectEqual(@as(u32, 1337), actual())
/// +mach.testing.expect(u32, 1337).equal(actual()) /// +mach.testing.expect(u32, 1337).eql(actual())
/// ``` /// ```
/// ///
/// ```diff /// ```diff
/// -std.testing.expectApproxEqAbs(@as(f32, 1.0), actual(), std.math.floatEps(f32)) /// -std.testing.expectApproxEqAbs(@as(f32, 1.0), actual(), std.math.floatEps(f32))
/// +mach.testing.expect(f32, 1.0).equal(actual()) /// +mach.testing.expect(f32, 1.0).eql(actual())
/// ``` /// ```
/// ///
/// ```diff /// ```diff
/// -std.testing.expectApproxEqAbs(@as(f32, 1.0), actual(), 0.1) /// -std.testing.expectApproxEqAbs(@as(f32, 1.0), actual(), 0.1)
/// +mach.testing.expect(f32, 1.0).equalApprox(actual(), 0.1) /// +mach.testing.expect(f32, 1.0).eqlApprox(actual(), 0.1)
/// ``` /// ```
/// ///
/// ```diff /// ```diff
/// -std.testing.expectEqual(@as(f32, 1.0), actual()) /// -std.testing.expectEqual(@as(f32, 1.0), actual())
/// +mach.testing.expect(f32, 1.0).equalBinary(actual()) /// +mach.testing.expect(f32, 1.0).eqlBinary(actual())
/// ``` /// ```
/// ///
/// ```diff /// ```diff
/// -std.testing.expectEqual(@as([]const u8, byte_array), actual()) /// -std.testing.expectEqual(@as([]const u8, byte_array), actual())
/// +mach.testing.expect([]const u8, byte_array).equalBinary(actual()) /// +mach.testing.expect([]const u8, byte_array).eqlBinary(actual())
/// ``` /// ```
/// ///
/// ```diff /// ```diff
/// -std.testing.expectEqualStrings("foo", actual()) /// -std.testing.expectEqualStrings("foo", actual())
/// +mach.testing.expect([]const u8, "foo").equal(actual()) /// +mach.testing.expect([]const u8, "foo").eql(actual())
/// ``` /// ```
/// ///
/// Note that std.testing cannot handle @Vector approximate equality at all, while mach.testing uses /// Note that std.testing cannot handle @Vector approximate equality at all, while mach.testing uses