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,
/// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(T));
pub fn eql(e: *const @This(), actual: T) !void {
try e.eqlApprox(actual, math.eps(T));
}
/// 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);
}
/// 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);
}
};
@ -32,15 +32,15 @@ fn ExpectVector(comptime T: type) type {
expected: T,
/// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(Elem));
pub fn eql(e: *const @This(), actual: T) !void {
try e.eqlApprox(actual, math.eps(Elem));
}
/// 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;
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] });
return error.TestExpectEqualEps;
}
@ -48,7 +48,7 @@ fn ExpectVector(comptime T: type) type {
}
/// 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);
}
};
@ -59,15 +59,15 @@ fn ExpectVecMat(comptime T: type) type {
expected: T,
/// Approximate (absolute epsilon tolerence) equality
pub fn equal(e: *const @This(), actual: T) !void {
try e.equalApprox(actual, math.eps(T.T));
pub fn eql(e: *const @This(), actual: T) !void {
try e.eqlApprox(actual, math.eps(T.T));
}
/// 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;
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] });
return error.TestExpectEqualEps;
}
@ -75,7 +75,7 @@ fn ExpectVecMat(comptime T: type) type {
}
/// 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);
}
};
@ -84,7 +84,7 @@ fn ExpectVecMat(comptime T: type) type {
fn ExpectComptime(comptime T: type) type {
return struct {
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);
}
};
@ -94,11 +94,11 @@ fn ExpectBytes(comptime T: type) type {
return struct {
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);
}
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);
}
};
@ -119,7 +119,7 @@ fn Expect(comptime T: type) type {
// Generic equality
return struct {
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);
}
};
@ -133,42 +133,42 @@ fn Expect(comptime T: type) type {
///
/// Floats, mach.math.Vec, and mach.math.Mat types support:
///
/// * `.equal(v)` (epsilon equality)
/// * `.equalApprox(v, tolerence)` (specific tolerence equality)
/// * `.equalBinary(v)` binary equality
/// * `.eql(v)` (epsilon equality)
/// * `.eqlApprox(v, tolerence)` (specific tolerence 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:
///
/// ```diff
/// -std.testing.expectEqual(@as(u32, 1337), actual())
/// +mach.testing.expect(u32, 1337).equal(actual())
/// +mach.testing.expect(u32, 1337).eql(actual())
/// ```
///
/// ```diff
/// -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
/// -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
/// -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
/// -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
/// -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