srctree

/// See also: `isWhitespace`

pub const whitespace = [_]u8{ ' ', '\t', '\n', '\r', control_code.vt, control_code.ff };

 

for (whitespace) |char| try std.testing.expect(isWhitespace(char));

 

var i: u8 = 0;

return output[0..ascii_string.len];

}

 

var buf: [1024]u8 = undefined;

const result = lowerString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");

try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);

return lowerString(result, ascii_string);

}

 

const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");

defer std.testing.allocator.free(result);

try std.testing.expectEqualStrings("abcdefghijklmnopqrst0234+💩!", result);

return output[0..ascii_string.len];

}

 

var buf: [1024]u8 = undefined;

const result = upperString(&buf, "aBcDeFgHiJkLmNOPqrst0234+💩!");

try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);

return upperString(result, ascii_string);

}

 

const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");

defer std.testing.allocator.free(result);

try std.testing.expectEqualStrings("ABCDEFGHIJKLMNOPQRST0234+💩!", result);

return true;

}

 

try std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));

try std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));

try std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));

return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[0..needle.len], needle);

}

 

try std.testing.expect(startsWithIgnoreCase("boB", "Bo"));

try std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));

}

return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[haystack.len - needle.len ..], needle);

}

 

try std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));

try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));

}

}

}

 

try std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14);

try std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null);

try std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);

 

try testPureBitSet(Set);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

 

try testStaticBitSet(IntegerBitSet(0));

try testStaticBitSet(IntegerBitSet(127));

}

 

inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {

try testStaticBitSet(ArrayBitSet(u8, size));

try testStaticBitSet(ArrayBitSet(u16, size));

}

}

 

const allocator = std.testing.allocator;

var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);

try testing.expectEqual(@as(usize, 0), a.count());

}

}

 

const allocator = std.testing.allocator;

var a = try DynamicBitSet.initEmpty(allocator, 300);

try testing.expectEqual(@as(usize, 0), a.count());

}

}

 

try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));

try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));

try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));

 

};

}

 

var a = try BoundedArray(u8, 64).init(32);

 

try testing.expectEqual(a.capacity(), 64);

 

return null;

}

 

try std.testing.expectEqual(CreateProcessSupportedExtension.exe, windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e' }).?);

try std.testing.expect(windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e', 'c' }) == null);

}

return try unicode.wtf8ToWtf16LeAllocZ(allocator, buf.items);

}

 

const t = testArgvToCommandLineWindows;

 

try t(&.{

return envp_buf;

}

 

const testing = std.testing;

const allocator = testing.allocator;

var envmap = EnvMap.init(allocator);

 

@memset(@as([]volatile T, s), 0);

}

 

var a: [100]u8 = undefined;

var b: [100]u8 = undefined;

random.bytes(a[0..]);

try testing.expect(timingSafeEql(@Vector(100, u8), v1, v3));

}

 

var a = [_]u8{10} ** 32;

var b = [_]u8{10} ** 32;

try testing.expectEqual(timingSafeCompare(u8, &a, &b, .big), .eq);

}

}

 

var a = [_]u8{0xfe} ** 8;

var b = [_]u8{0xfe} ** 8;

 

 

return null;

}

 

const symbols = [_]MachoSymbol{

.{ .addr = 100, .strx = undefined, .size = undefined, .ofile = undefined },

.{ .addr = 200, .strx = undefined, .size = undefined, .ofile = undefined },

}

}

 

var output = std.ArrayList(u8).init(std.testing.allocator);

defer output.deinit();

const output_stream = output.writer();

}

};

 

test {

_ = &dump_hex;

}

 

}

}

 

inline for ([_]type{ u1, u8, u16, u64 }) |T| {

inline for ([_]LinearFifoBufferType{ LinearFifoBufferType{ .Static = 32 }, .Slice, .Dynamic }) |bt| {

const FifoType = LinearFifo(T, bt);

 

return .{ .data = data };

}

 

var buf: [24]u8 = undefined;

inline for (.{

.{ .s = "0ns", .d = 0 },

return .{ .data = ns };

}

 

var buf: [24]u8 = undefined;

inline for (.{

.{ .s = "0ns", .d = 0 },

return parseWithSign(T, buf, base, .pos);

}

 

try std.testing.expect((try parseInt(i32, "-10", 10)) == -10);

try std.testing.expect((try parseInt(i32, "+10", 10)) == 10);

try std.testing.expect((try parseInt(u32, "+10", 10)) == 10);

return parseWithSign(T, buf, base, .pos);

}

 

try std.testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);

try std.testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);

try std.testing.expect((try parseUnsigned(u16, "65_535", 10)) == 65535);

return math.mul(usize, number, multiplier);

}

 

try std.testing.expect(try parseIntSizeSuffix("2", 10) == 2);

try std.testing.expect(try parseIntSizeSuffix("2B", 10) == 2);

try std.testing.expect(try parseIntSizeSuffix("2kB", 10) == 2000);

return result[0 .. result.len - 1 :0];

}

 

var buffer: [100]u8 = undefined;

const buf = buffer[0..];

 

}

}

 

@setEvalBranchQuota(2000);

try std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptimePrint("{}", .{100})));

try std.testing.expectEqualSlices(u8, "100", comptimePrint("{}", .{100}));

return out[0 .. in_i / 2];

}

 

const input = "input slice";

const encoded = bytesToHex(input, .lower);

var decoded: [input.len]u8 = undefined;

try std.testing.expectEqualSlices(u8, input, try hexToBytes(&decoded, &encoded));

}

 

var buf: [32]u8 = undefined;

try expectFmt("90" ** 32, "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "90" ** 32))});

try expectFmt("ABCD", "{s}", .{fmtSliceHexUpper(try hexToBytes(&buf, "ABCD"))});

 

const math = std.math;

const testing = std.testing;

const expect = testing.expect;

const expectError = testing.expectError;

const approxEqAbs = std.math.approxEqAbs;

const epsilon = 1e-7;

 

// See https://github.com/tiehuis/parse-number-fxx-test-data for a wider-selection of test-data.

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

try testing.expectError(error.InvalidCharacter, parseFloat(T, ""));

try testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));

 

 

}

}

 

if (native_os == .wasi) return error.SkipZigTest;

 

// We can't actually validate the result

 

try testing.expectEqualSlices(u8, expected, if (zero) actual[0 .. actual.len - 1 :0] else actual);

}

 

{

const actual: []u8 = try join(testing.allocator, &[_][]const u8{});

defer testing.allocator.free(actual);

return isAbsolutePosix(mem.sliceTo(path_c, 0));

}

 

try testIsAbsoluteWindows("", false);

try testIsAbsoluteWindows("/", true);

try testIsAbsoluteWindows("//", true);

try testIsAbsoluteWindows("/usr/local", true);

}

 

try testIsAbsolutePosix("", false);

try testIsAbsolutePosix("/home/foo", true);

try testIsAbsolutePosix("/home/foo/..", true);

return relative_path;

}

 

{

const parsed = windowsParsePath("//a/b");

try testing.expect(parsed.is_abs);

return path[0..end_index];

}

 

try testDirnamePosix("/a/b/c", "/a/b");

try testDirnamePosix("/a/b/c///", "/a/b");

try testDirnamePosix("/a", "/");

try testDirnamePosix("a//", null);

}

 

try testDirnameWindows("c:\\", null);

try testDirnameWindows("c:\\foo", "c:\\");

try testDirnameWindows("c:\\foo\\", "c:\\");

return path[start_index + 1 .. end_index];

}

 

try testBasename("", "");

try testBasename("/", "");

try testBasename("/dir/basename.ext", "basename.ext");

return [_]u8{};

}

 

try testRelativeWindows("c:/blah\\blah", "d:/games", "D:\\games");

try testRelativeWindows("c:/aaaa/bbbb", "c:/aaaa", "..");

try testRelativeWindows("c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc");

try testing.expectEqualStrings(expected, extension(path));

}

 

try testExtension("", "");

try testExtension(".", "");

try testExtension("a.", ".");

try testing.expectEqualStrings(expected, stem(path));

}

 

try testStem("hello/world/lib.tar.gz", "lib.tar");

try testStem("hello/world/lib.tar", "lib");

try testStem("hello/world/lib", "lib");

 

return data.len;

}

 

null_writer.writeAll("yay" ** 10) catch |err| switch (err) {};

}

 

 

return @abs(x - y) <= @max(@abs(x), @abs(y)) * tolerance;

}

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

const eps_value = comptime floatEps(T);

const min_value = comptime floatMin(T);

 

try testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value));

try testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value));

try testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value));

try testing.expect(!approxEqAbs(T, 1.0 + 2 * eps_value, 1.0, eps_value));

try testing.expect(approxEqAbs(T, 1.0 + 1 * eps_value, 1.0, eps_value));

try testing.expect(approxEqAbs(T, min_value, 0.0, eps_value * 2));

try testing.expect(approxEqAbs(T, -min_value, 0.0, eps_value * 2));

}

// possible epsilon value like we do in the tests above. In the same vein, we

// also can't represent a max/min, `NaN` or `Inf` values.

const eps_value = 1e-4;

 

try testing.expect(approxEqAbs(comptime_float, 0.0, 0.0, eps_value));

try testing.expect(approxEqAbs(comptime_float, -0.0, -0.0, eps_value));

try testing.expect(approxEqAbs(comptime_float, 0.0, -0.0, eps_value));

try testing.expect(!approxEqAbs(comptime_float, 1.0 + 2 * eps_value, 1.0, eps_value));

try testing.expect(approxEqAbs(comptime_float, 1.0 + 1 * eps_value, 1.0, eps_value));

}

}

 

pub const doNotOptimizeAway = @compileError("Deprecated: use `std.mem.doNotOptimizeAway` instead");

 

pub fn raiseInvalid() void {

@compileError("Input must be float or a comptime number, or a vector of floats.");

}

 

const zero: f32 = 0;

const half_pi: f32 = pi / 2.0;

const neg_quart_pi: f32 = -pi / 4.0;

@compileError("Input must be float or a comptime number, or a vector of floats.");

}

 

const ninety: f32 = 90;

const neg_two_seventy: f32 = -270;

const three_sixty: f32 = 360;

},

}

}

// Within range

try testing.expect(wrap(@as(i32, -75), @as(i32, 180)) == -75);

try testing.expect(wrap(@as(i32, -75), @as(i32, -180)) == -75);

var i: i32 = 1;

_ = &i;

try testing.expect(wrap(i, 10) == 1);

const limit: i32 = 180;

// Within range

try testing.expect(wrap(@as(i32, -75), limit) == -75);

assert(lower <= upper);

return @max(lower, @min(val, upper));

}

// Within range

try testing.expect(std.math.clamp(@as(i32, -1), @as(i32, -4), @as(i32, 7)) == -1);

// Below

return a << casted_shift_amt;

}

 

if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {

// https://github.com/ziglang/zig/issues/12012

return error.SkipZigTest;

return a >> casted_shift_amt;

}

 

if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {

// https://github.com/ziglang/zig/issues/12012

return error.SkipZigTest;

}

}

 

if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {

// https://github.com/ziglang/zig/issues/12012

return error.SkipZigTest;

}

}

 

if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {

// https://github.com/ziglang/zig/issues/12012

return error.SkipZigTest;

return std.meta.Int(signedness, magnitude_bits);

}

 

try testing.expect(IntFittingRange(0, 0) == u0);

try testing.expect(IntFittingRange(0, 1) == u1);

try testing.expect(IntFittingRange(0, 2) == u2);

return @divTrunc(numerator, denominator);

}

 

try testDivTrunc();

try comptime testDivTrunc();

}

return @divFloor(numerator, denominator);

}

 

try testDivFloor();

try comptime testDivFloor();

}

}

}

 

try testDivCeil();

try comptime testDivCeil();

}

return result;

}

 

try testDivExact();

try comptime testDivExact();

}

return @mod(numerator, denominator);

}

 

try testMod();

try comptime testMod();

}

return @rem(numerator, denominator);

}

 

try testRem();

try comptime testRem();

}

return -@as(int, @intCast(x));

}

 

try testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999);

try testing.expect(@TypeOf(negateCast(@as(u32, 999)) catch unreachable) == i32);

 

}

}

 

try testing.expect(cast(u8, 300) == null);

try testing.expect(cast(u8, @as(u32, 300)) == null);

try testing.expect(cast(i8, -200) == null);

return extended_type;

}

 

try testing.expect(ByteAlignedInt(u0) == u0);

try testing.expect(ByteAlignedInt(i0) == i0);

try testing.expect(ByteAlignedInt(u3) == u8);

return @as(T, 1) << log2_int(uT, @as(uT, @intCast(value)));

}

 

try testFloorPowerOfTwo();

try comptime testFloorPowerOfTwo();

}

return ceilPowerOfTwo(T, value) catch unreachable;

}

 

try testCeilPowerOfTwoPromote();

try comptime testCeilPowerOfTwoPromote();

}

try testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9));

}

 

try testCeilPowerOfTwo();

try comptime testCeilPowerOfTwo();

}

}

}

 

try testing.expect(lossyCast(i16, 70000.0) == @as(i16, 32767));

try testing.expect(lossyCast(u32, @as(i16, -255)) == @as(u32, 0));

try testing.expect(lossyCast(i9, @as(u32, 200)) == @as(i9, 200));

return @mulAdd(Type, b - a, t, a);

}

 

if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/17884

if (builtin.zig_backend == .stage2_x86_64 and

!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .fma)) return error.SkipZigTest;

return -(1 << (bit_count - 1));

}

 

try testing.expect(maxInt(u0) == 0);

try testing.expect(maxInt(u1) == 1);

try testing.expect(maxInt(u8) == 255);

try testing.expect(maxInt(i63) == 4611686018427387903);

try testing.expect(maxInt(i64) == 9223372036854775807);

try testing.expect(maxInt(i128) == 170141183460469231731687303715884105727);

 

try testing.expect(minInt(u0) == 0);

try testing.expect(minInt(u1) == 0);

try testing.expect(minInt(u8) == 0);

return @as(ResultInt, a) * @as(ResultInt, b);

}

 

try testing.expect(mulWide(u8, 5, 5) == 25);

try testing.expect(mulWide(i8, 5, -5) == -25);

try testing.expect(mulWide(u8, 100, 100) == 10000);

};

}

 

pub fn compare(self: Order, op: CompareOperator) bool {

return switch (self) {

.lt => switch (op) {

},

};

}

};

 

/// Given two numbers, this function returns the order they are with respect to each other.

.neq => .neq,

};

}

};

 

/// This function does the same thing as comparison operators, however the

};

}

 

try testing.expect(compare(@as(i8, -1), .lt, @as(u8, 255)));

try testing.expect(compare(@as(i8, 2), .gt, @as(u8, 1)));

try testing.expect(!compare(@as(i8, -1), .gte, @as(u8, 255)));

try testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));

}

 

try testing.expect(order(0, 0) == .eq);

try testing.expect(order(1, 0) == .gt);

try testing.expect(order(-1, 0) == .lt);

}

 

/// Returns a mask of all ones if value is true,

/// and a mask of all zeroes if value is false.

/// Compiles to one instruction for register sized integers.

return -%@as(MaskInt, @intCast(@intFromBool(value)));

}

 

const runTest = struct {

fn runTest() !void {

try testing.expectEqual(@as(u1, 0), boolMask(u1, false));

try std.testing.expectEqual(0.0, sign(0.0));

}

 

if (builtin.zig_backend == .stage2_llvm) {

// https://github.com/ziglang/zig/issues/12012

return error.SkipZigTest;

 

}

}

 

const C_struct = extern struct {

x: u32,

y: u32 align(128),

}

}

 

const I = struct {

d: f64,

};

return math.order(lhs[i], rhs[i]);

}

 

try testing.expect(order(u8, "abcd", "bee") == .lt);

try testing.expect(order(u8, "abc", "abc") == .eq);

try testing.expect(order(u8, "abc", "abc0") == .lt);

try testing.expect(order(u8, "", "") == .eq);

try testing.expect(order(u8, "", "a") == .lt);

try testing.expect(orderZ(u8, "", "a") == .lt);

}

 

return order(T, lhs, rhs) == .lt;

}

 

try testing.expect(lessThan(u8, "abcd", "bee"));

try testing.expect(!lessThan(u8, "abc", "abc"));

try testing.expect(lessThan(u8, "abc", "abc0"));

return if (a.len == b.len) null else shortest;

}

 

try testing.expectEqual(indexOfDiff(u8, "one", "one"), null);

try testing.expectEqual(indexOfDiff(u8, "one two", "one"), 3);

try testing.expectEqual(indexOfDiff(u8, "one", "one two"), 3);

@compileError("invalid type given to std.mem.span: " ++ @typeName(T));

}

 

try testing.expect(Span([*:1]u16) == [:1]u16);

try testing.expect(Span(?[*:1]u16) == ?[:1]u16);

try testing.expect(Span([*:1]const u8) == [:1]const u8);

}

}

 

var array: [5]u16 = [_]u16{ 1, 2, 3, 4, 5 };

const ptr = @as([*:3]u16, array[0..2 :3]);

try testing.expect(eql(u16, span(ptr), &[_]u16{ 1, 2 }));

}

}

 

try testing.expectEqualSlices(u8, "aoeu", sliceTo("aoeu", 0));

 

{

@compileError("invalid type given to std.mem.sliceTo: " ++ @typeName(@TypeOf(ptr)));

}

 

try testing.expect(lenSliceTo("aoeu", 0) == 4);

 

{

}

}

 

var array: [5]u16 = [_]u16{ 1, 2, 0, 4, 5 };

const ptr = @as([*:4]u16, array[0..3 :4]);

try testing.expect(len(ptr) == 3);

var i: usize = 0;

 

if (backend_supports_vectors and

!@inComptime() and

(@typeInfo(T) == .Int or @typeInfo(T) == .Float) and std.math.isPowerOfTwo(@bitSizeOf(T)))

{

return slice[begin..end];

}

 

try testing.expectEqualSlices(u8, "foo\n ", trimLeft(u8, " foo\n ", " \n"));

try testing.expectEqualSlices(u8, " foo", trimRight(u8, " foo\n ", " \n"));

try testing.expectEqualSlices(u8, "foo", trim(u8, " foo\n ", " \n"));

 

var i: usize = start_index;

if (backend_supports_vectors and

!@inComptime() and

(@typeInfo(T) == .Int or @typeInfo(T) == .Float) and std.math.isPowerOfTwo(@bitSizeOf(T)))

{

return null;

}

 

const Types = [_]type{ u8, u16, u32, u64 };

 

inline for (Types) |T| {

return null;

}

 

try testing.expect(indexOfNone(u8, "abc123", "123").? == 0);

try testing.expect(lastIndexOfNone(u8, "abc123", "123").? == 2);

try testing.expect(indexOfNone(u8, "123abc", "123").? == 3);

return null;

}

 

try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8);

try testing.expect(lastIndexOf(u8, "one two three four five six seven eight nine ten eleven", "three four").? == 8);

try testing.expect(indexOf(u8, "one two three four five six seven eight nine ten eleven", "two two") == null);

return found;

}

 

try testing.expect(count(u8, "", "h") == 0);

try testing.expect(count(u8, "h", "h") == 1);

try testing.expect(count(u8, "hh", "h") == 2);

return false;

}

 

try testing.expect(containsAtLeast(u8, "aa", 0, "a"));

try testing.expect(containsAtLeast(u8, "aa", 1, "a"));

try testing.expect(containsAtLeast(u8, "aa", 2, "a"));

 

try testing.expect(readInt(i16, &[_]u8{ 0xff, 0xfd }, .big) == -3);

try testing.expect(readInt(i16, &[_]u8{ 0xfc, 0xff }, .little) == -4);

}

 

fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T {

}

}

 

const T = extern struct {

f0: u8,

f1: u16,

};

}

 

var it = tokenizeScalar(u8, " abc def ghi ", ' ');

try testing.expect(eql(u8, it.next().?, "abc"));

try testing.expect(eql(u8, it.peek().?, "def"));

try testing.expect(it16.next() == null);

}

 

var it = tokenizeAny(u8, "a|b,c/d e", " /,|");

try testing.expect(eql(u8, it.next().?, "a"));

try testing.expect(eql(u8, it.peek().?, "b"));

try testing.expect(it16.next() == null);

}

 

var it = tokenizeSequence(u8, "a<>b<><>c><>d><", "<>");

try testing.expectEqualStrings("a", it.next().?);

try testing.expectEqualStrings("b", it.peek().?);

};

}

 

var it = splitScalar(u8, "abc|def||ghi", '|');

try testing.expectEqualSlices(u8, it.rest(), "abc|def||ghi");

try testing.expectEqualSlices(u8, it.first(), "abc");

try testing.expect(it16.next() == null);

}

 

var it = splitSequence(u8, "a, b ,, c, d, e", ", ");

try testing.expectEqualSlices(u8, it.first(), "a");

try testing.expectEqualSlices(u8, it.rest(), "b ,, c, d, e");

try testing.expect(it16.next() == null);

}

 

var it = splitAny(u8, "a,b, c d e", ", ");

try testing.expectEqualSlices(u8, it.first(), "a");

try testing.expectEqualSlices(u8, it.rest(), "b, c d e");

};

}

 

var it = splitBackwardsScalar(u8, "abc|def||ghi", '|');

try testing.expectEqualSlices(u8, it.rest(), "abc|def||ghi");

try testing.expectEqualSlices(u8, it.first(), "ghi");

try testing.expect(it16.next() == null);

}

 

var it = splitBackwardsSequence(u8, "a, b ,, c, d, e", ", ");

try testing.expectEqualSlices(u8, it.rest(), "a, b ,, c, d, e");

try testing.expectEqualSlices(u8, it.first(), "e");

try testing.expect(it16.next() == null);

}

 

var it = splitBackwardsAny(u8, "a,b, c d e", ", ");

try testing.expectEqualSlices(u8, it.rest(), "a,b, c d e");

try testing.expectEqualSlices(u8, it.first(), "e");

};

}

 

{

// moving average size 3

var it = window(u8, "abcdefg", 3, 1);

return if (needle.len > haystack.len) false else eql(T, haystack[0..needle.len], needle);

}

 

try testing.expect(startsWith(u8, "Bob", "Bo"));

try testing.expect(!startsWith(u8, "Needle in haystack", "haystack"));

}

return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len ..], needle);

}

 

try testing.expect(endsWith(u8, "Needle in haystack", "haystack"));

try testing.expect(!endsWith(u8, "Bob", "Bo"));

}

return buf;

}

 

{

const str = try join(testing.allocator, ",", &[_][]const u8{});

defer testing.allocator.free(str);

}

}

 

{

const str = try joinZ(testing.allocator, ",", &[_][]const u8{});

defer testing.allocator.free(str);

return buf;

}

 

{

const str = try concat(testing.allocator, u8, &[_][]const u8{ "abc", "def", "ghi" });

defer testing.allocator.free(str);

}

}

 

try testing.expect(eql(u8, "abcd", "abcd"));

try testing.expect(!eql(u8, "abcdef", "abZdef"));

try testing.expect(!eql(u8, "abcdefg", "abcdef"));

}

 

{

const bytes = [_]u8{

0x12,

return best;

}

 

try testing.expectEqual(min(u8, "abcdefg"), 'a');

try testing.expectEqual(min(u8, "bcdefga"), 'a');

try testing.expectEqual(min(u8, "a"), 'a');

return best;

}

 

try testing.expectEqual(max(u8, "abcdefg"), 'g');

try testing.expectEqual(max(u8, "gabcdef"), 'g');

try testing.expectEqual(max(u8, "g"), 'g');

return index;

}

 

try testing.expectEqual(indexOfMin(u8, "abcdefg"), 0);

try testing.expectEqual(indexOfMin(u8, "bcdefga"), 6);

try testing.expectEqual(indexOfMin(u8, "a"), 0);

return index;

}

 

try testing.expectEqual(indexOfMax(u8, "abcdefg"), 6);

try testing.expectEqual(indexOfMax(u8, "gabcdef"), 0);

try testing.expectEqual(indexOfMax(u8, "a"), 0);

return .{ minIdx, maxIdx };

}

 

try testing.expectEqual(.{ 0, 6 }, indexOfMinMax(u8, "abcdefg"));

try testing.expectEqual(.{ 1, 0 }, indexOfMinMax(u8, "gabcdef"));

try testing.expectEqual(.{ 0, 0 }, indexOfMinMax(u8, "a"));

}

}

 

var arr = [_]i32{ 5, 3, 1, 2, 4 };

reverse(i32, arr[0..]);

 

return .{ .ptr = slice.ptr, .index = slice.len };

}

 

{

var it = reverseIterator("abc");

try testing.expectEqual(@as(?u8, 'c'), it.next());

reverse(T, items);

}

 

var arr = [_]i32{ 5, 3, 1, 2, 4 };

rotate(i32, arr[0..], 2);

 

return replacements;

}

 

var output: [29]u8 = undefined;

var replacements = replace(u8, "All your base are belong to us", "base", "Zig", output[0..]);

var expected: []const u8 = "All your Zig are belong to us";

defer std.testing.allocator.free(mutable);

try testing.expect(std.mem.eql(u8, collapseRepeats(u8, mutable, elem), expected));

}

try testCollapseRepeats("", '/', "");

try testCollapseRepeats("a", '/', "a");

try testCollapseRepeats("/", '/', "/");

return size;

}

 

try testing.expect(replacementSize(u8, "All your base are belong to us", "base", "Zig") == 29);

try testing.expect(replacementSize(u8, "Favor reading code over writing code.", "code", "") == 29);

try testing.expect(replacementSize(u8, "Only one obvious way to do things.", "things.", "things in Zig.") == 41);

return output;

}

 

const gpa = std.testing.allocator;

 

const base_replace = replaceOwned(u8, gpa, "All your base are belong to us", "base", "Zig") catch @panic("out of memory");

return @alignCast(ptr + adjust_off);

}

 

const S = struct {

fn checkAlign(comptime T: type, base: usize, align_to: usize, expected: usize) !void {

const ptr: T = @ptrFromInt(base);

return @ptrCast(@alignCast(ptr));

}

 

const deadbeef = @as(u32, 0xDEADBEEF);

const deadbeef_bytes = switch (native_endian) {

.big => "\xDE\xAD\xBE\xEF",

return asBytes(&value).*;

}

 

var my_bytes = toBytes(@as(u32, 0x12345678));

switch (native_endian) {

.big => try testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")),

return @ptrCast(bytes);

}

 

const deadbeef = @as(u32, 0xDEADBEEF);

const deadbeef_bytes = switch (native_endian) {

.big => "\xDE\xAD\xBE\xEF",

pub fn bytesToValue(comptime T: type, bytes: anytype) T {

return bytesAsValue(T, bytes).*;

}

const deadbeef_bytes = switch (native_endian) {

.big => "\xDE\xAD\xBE\xEF",

.little => "\xEF\xBE\xAD\xDE",

return @as(cast_target, @ptrCast(bytes))[0..@divExact(bytes.len, @sizeOf(T))];

}

 

{

const bytes = [_]u8{ 0xDE, 0xAD, 0xBE, 0xEF };

const slice = bytesAsSlice(u16, bytes[0..]);

return @as(cast_target, @ptrCast(slice))[0 .. slice.len * @sizeOf(std.meta.Elem(Slice))];

}

 

const bytes = [_]u16{ 0xDEAD, 0xBEEF };

const slice = sliceAsBytes(bytes[0..]);

try testing.expect(slice.len == 4);

dest.* = 0;

}

 

comptime doNotOptimizeAway("test");

 

doNotOptimizeAway(null);

doNotOptimizeAway(@as(std.builtin.Endian, .little));

}

 

try testing.expect(alignForward(usize, 1, 1) == 1);

try testing.expect(alignForward(usize, 2, 1) == 2);

try testing.expect(alignForward(usize, 1, 2) == 2);

return alignBackward(T, addr, alignment) == addr;

}

 

try testing.expect(isAligned(0, 4));

try testing.expect(isAligned(1, 1));

try testing.expect(isAligned(2, 1));

 

};

}

 

const Flags = TrailerFlags(struct {

a: i32,

b: bool,

 

}

}

 

if (builtin.os.tag != .windows)

return;

 

}

}

 

const L = std.unicode.utf8ToUtf16LeStringLiteral;

 

try testNtToWin32Namespace(L("UNC"), L("\\??\\UNC"));

}

};

 

try std.testing.expectEqual(

GUID{

.Data1 = 0x01234567,

 

}

};

 

var env = EnvMap.init(testing.allocator);

defer env.deinit();

 

}

}

 

var env = try getEnvMap(testing.allocator);

defer env.deinit();

}

return allocator.free(aligned_allocated_buf);

}

 

const t = testArgIteratorWindows;

 

try t(

 

return null;

}

 

const S = struct {

fn order_u32(context: void, lhs: u32, rhs: u32) math.Order {

_ = context;

return left;

}

 

const S = struct {

fn lower_u32(context: void, lhs: u32, rhs: u32) bool {

_ = context;

return left;

}

 

const S = struct {

fn lower_u32(context: void, lhs: u32, rhs: u32) bool {

_ = context;

};

}

 

const S = struct {

fn lower_u32(context: void, lhs: u32, rhs: u32) bool {

_ = context;

return smallest_index;

}

 

try testing.expectEqual(@as(?usize, null), argMin(i32, &[_]i32{}, {}, asc_i32));

try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{1}, {}, asc_i32));

try testing.expectEqual(@as(?usize, 0), argMin(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

return items[i];

}

 

try testing.expectEqual(@as(?i32, null), min(i32, &[_]i32{}, {}, asc_i32));

try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{1}, {}, asc_i32));

try testing.expectEqual(@as(?i32, 1), min(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

return biggest_index;

}

 

try testing.expectEqual(@as(?usize, null), argMax(i32, &[_]i32{}, {}, asc_i32));

try testing.expectEqual(@as(?usize, 0), argMax(i32, &[_]i32{1}, {}, asc_i32));

try testing.expectEqual(@as(?usize, 4), argMax(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

return items[i];

}

 

try testing.expectEqual(@as(?i32, null), max(i32, &[_]i32{}, {}, asc_i32));

try testing.expectEqual(@as(?i32, 1), max(i32, &[_]i32{1}, {}, asc_i32));

try testing.expectEqual(@as(?i32, 5), max(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

return true;

}

 

try testing.expect(isSorted(i32, &[_]i32{}, {}, asc_i32));

try testing.expect(isSorted(i32, &[_]i32{10}, {}, asc_i32));

try testing.expect(isSorted(i32, &[_]i32{ 1, 2, 3, 4, 5 }, {}, asc_i32));

 

return path[i..];

}

 

const expectEqualStrings = testing.expectEqualStrings;

try expectEqualStrings("a/b/c", stripComponents("a/b/c", 0));

try expectEqualStrings("b/c", stripComponents("a/b/c", 1));

try expectEqualStrings("", stripComponents("a/b/c", 4));

}

 

const Attr = struct {

kind: PaxAttributeKind,

value: []const u8 = undefined,

 

}

}

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

const pos_x: T = 12.0;

const pos_y: T = 12.06;

}

}

 

inline for ([_]type{ f16, f32, f64, f128 }) |T| {

const eps_value = comptime math.floatEps(T);

const sqrt_eps_value = comptime @sqrt(eps_value);

 

posix.nanosleep(s, ns);

}

 

sleep(1);

}

 

}

}

 

const margin = ns_per_ms * 50;

 

const time_0 = milliTimestamp();

}

};

 

const margin = ns_per_ms * 150;

 

var timer = try Timer.start();

 

return (0 == @mod(year, 400));

}

 

try testing.expectEqual(false, isLeapYear(2095));

try testing.expectEqual(true, isLeapYear(2096));

try testing.expectEqual(false, isLeapYear(2100));

 

return .{ .data = utf8 };

}

 

const expectFmt = testing.expectFmt;

try expectFmt("", "{}", .{fmtUtf8("")});

try expectFmt("foo", "{}", .{fmtUtf8("foo")});

return dest_index;

}

 

var utf16le: [128]u16 = undefined;

{

const length = try utf8ToUtf16Le(utf16le[0..], "𐐷");

return .{ .data = utf16le };

}

 

const expectFmt = testing.expectFmt;

try expectFmt("", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral(""))});

try expectFmt("foo", "{}", .{fmtUtf16Le(utf8ToUtf16LeStringLiteral("foo"))});

try expectFmt("", "{}", .{fmtUtf16Le(&[_]u16{mem.readInt(u16, "\x00\xe0", native_endian)})});

}

 

{

const bytes = [_:0]u16{

mem.nativeToLittle(u16, 0x41),

 

return res;

}

 

try testing.expectEqual(

@as(CountResult, .{

.leaked = 0,

return res;

}

 

try testing.expectEqual(

@as(CountResult, .{

.leaked = 0,

 

i += 1;

}

}

 

 

}

 

.line = 1,

.column = 2,

.span_start = 3,

.span_main = 4,

.span_end = 5,

 

 

 

 

 

 

 

 

 

return true;

}

 

const expect = std.testing.expect;

try expect(!isPrimitive(""));

try expect(!isPrimitive("_"));

 

}

}

 

try std.testing.expectEqual(

ParsedCharLiteral{ .success = 'a' },

parseCharLiteral("'a'"),

}

}

 

const expect = std.testing.expect;

const expectError = std.testing.expectError;

const eql = std.mem.eql;

 

}

 

test "comptime bitcast with fields following f80" {

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

 

}

 

test "bitcast packed union to integer" {

const U = packed union {

x: u1,

y: u2,

 

}

 

test "reinterpret extern union" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

const U = extern union {