跳转到内容

std.zig.parser_fuzz

标准库Zig 0.17.0官方原文
源码std/zig/parser_fuzz.zig

第 1 行

std.zig.parser_fuzz.Allocator

别名

第 2 行

别名目标 std.mem.Allocator

std.zig.parser_fuzz.checkAgainstOracle

函数

第 161 行

fn checkAgainstOracle(source: [:0]const u8) !void

参数

source: [:0]const u8

std.zig.parser_fuzz.fuzzAgainstOracle

函数

第 11 行

fn fuzzAgainstOracle(_: void, smith: *Smith) !void

参数

_: void
smith: *Smith

std.zig.parser_fuzz.logBadSource

函数

第 180 行

fn logBadSource(source: []const u8, ast: std.zig.Ast) void

参数

source: []const u8
ast: std.zig.Ast

std.zig.parser_fuzz.logBadSourceInner

函数

第 188 行

fn logBadSourceInner(source: []const u8, t: std.Io.Terminal, ast: std.zig.Ast) std.Io.Writer.Error!void

参数

source: []const u8
t: std.Io.Terminal
ast: std.zig.Ast

错误

WriteFailed

详细诊断信息见 Writer 实现。

std.zig.parser_fuzz.logSource

函数

第 202 行

pub fn logSource(source: []const u8) void

参数

source: []const u8

std.zig.parser_fuzz.logSourceInner

函数

第 210 行

fn logSourceInner(source: []const u8, t: std.Io.Terminal) std.Io.Writer.Error!void

参数

source: []const u8
t: std.Io.Terminal

错误

WriteFailed

详细诊断信息见 Writer 实现。

std.zig.parser_fuzz.oracle

别名

第 5 行

别名目标 std.zig.parser_generated_oracle

std.zig.parser_fuzz.Smith

别名

第 3 行

别名目标 std.testing.Smith

std.zig.parser_fuzz.std

别名

第 1 行

别名目标 std

源码

std/zig/parser_fuzz.zig

const std = @import("../std.zig");
const Allocator = std.mem.Allocator;
const Smith = std.testing.Smith;

const oracle = @import("parser_generated_oracle.zig");

test "fuzz std.zig.Ast.parse() against generated oracle" {
    try std.testing.fuzz({}, fuzzAgainstOracle, .{});
}

fn fuzzAgainstOracle(_: void, smith: *Smith) !void {
    var buffer: [1 << 14]u8 = undefined;
    const len = smith.slice(buffer[0 .. buffer.len - 1]);
    buffer[len] = 0;
    const source = buffer[0..len :0];

    checkAgainstOracle(source) catch |err| switch (err) {
        error.MaxDepth => return error.SkipZigTest,
        else => |e| return e,
    };
}

test "max depth" {
    try std.testing.expectError(error.MaxDepth, checkAgainstOracle("((((("));
    _ = checkAgainstOracle("((((") catch |err| switch (err) {
        error.MaxDepth => try std.testing.expect(false),
        else => |e| return e,
    };
}

// 使用 AFL++ 发现
test "operator whitespace" {
    try checkAgainstOracle(
        \\test {
        \\    _!= 0;
        \\}
    );
    try checkAgainstOracle(
        \\test{{\\
        \\*0;}}
    );
}

// 使用 AFL++ 发现
test "doc comment or division operator" {
    try checkAgainstOracle("0=0///\n0");
}

// 使用 AFL++ 发现
test "double ampersand" {
    try checkAgainstOracle("0=0&&0"); // 错误
    try checkAgainstOracle("test{&&0;}"); // 成功
}

// 使用 AFL++ 发现
test "newline required before doc comment not at start of file" {
    try checkAgainstOracle("0,///\n0"); // 错误
    try checkAgainstOracle("///\n0"); // 成功
    try checkAgainstOracle(" ///\n0"); // 成功
    try checkAgainstOracle("\n///\n0"); // 成功
    try checkAgainstOracle("///"); // 错误
    try checkAgainstOracle("///\n//!");
    try checkAgainstOracle("///\ntest {}");
    try checkAgainstOracle("///\ncomptime 0");
}

// 使用 AFL++ 发现
test "extra capture in for loop" {
    try checkAgainstOracle("for(0)|t,r|0");
}

// 使用 AFL++ 发现
test "expression nesting" {
    try checkAgainstOracle("test{*comptime 0 == 0;}");
}

// 使用 AFL++ 发现
test "comptime fn" {
    try checkAgainstOracle("comptime fn()0");
}

// 使用 AFL++ 发现
test "return asterisk" {
    try checkAgainstOracle("test{return*!0;}");
}

// 使用 AFL++ 发现
test "fn container field" {
    try checkAgainstOracle("fn()0");
}

// 使用 AFL++ 发现
test "at newline string" {
    try checkAgainstOracle(
        \\@
        \\""
    );
}

// 使用 AFL++ 发现
test "string lit" {
    try checkAgainstOracle(
        \\"\\"
    );
}

// 使用 AFL++ 发现
test "dot question" {
    try checkAgainstOracle("0. ?");
}

// 使用 AFL++ 发现
test "volatile const" {
    try checkAgainstOracle("*volatile\nconst\n0");
}

// 使用 AFL++ 发现
test "addrspace align" {
    try checkAgainstOracle("*addrspace(0) align(0) 0");
    try checkAgainstOracle("*align(0) addrspace(0) 0");
    try checkAgainstOracle("[*]addrspace(0) align(0) 0");
    try checkAgainstOracle("[*]align(0) addrspace(0) 0");
}

// 使用 AFL++ 发现
test "catch capture whitespace" {
    try checkAgainstOracle("test{0 catch |h|0;}");
}

// 使用 AFL++ 发现
test "byte order mark" {
    // https://en.wikipedia.org/wiki/Byte_order_mark
    try checkAgainstOracle("\xef\xbb\xbf");
    try checkAgainstOracle("\xef\xbb\xbf///\n0");
}

// 使用 AFL++ 发现
test "nosuspend multi assign" {
    try checkAgainstOracle("test{nosuspend*0,var _=0;}");
}

// 使用 AFL++ 发现
test "bin op at end of file" {
    try checkAgainstOracle(
        \\test {
        \\    _ = 00
        \\|
    );
}

// 使用 AFL++ 发现
test "resume block chained compare ops" {
    try checkAgainstOracle("test{resume{0 > 0;} > 0 > 0;}");
}

// 使用 AFL++ 发现
test "for multiassign" {
    try checkAgainstOracle("test{for(0)|t|0,const w=0;}");
}

fn checkAgainstOracle(source: [:0]const u8) !void {
    var fba_buf: [1 << 18]u8 = undefined;
    var fba: std.heap.FixedBufferAllocator = .init(&fba_buf);

    const expected = try oracle.parse(source);

    // 模糊测试必须禁用错误恢复。
    // 考虑文件开头就存在解析错误,
    // 其后却跟着包含一百万层嵌套括号的合法声明的情况。判定器会
    // 立即遇到解析错误且不执行恢复,因此不会因超过最大深度
    // 而跳过此输入。但 std.zig.Ast.parse() 默认会执行恢复,
    // 于是会触发栈溢出,而非在解析错误后返回。
    // 栈溢出并非有价值的测试目标,因此不希望模糊测试器发现这类情况。
    const ast = try std.zig.Ast.parse(fba.allocator(), source, .{ .recover = false });

    errdefer logBadSource(source, ast);
    try std.testing.expectEqual(expected, ast.errors.len == 0);
}

fn logBadSource(source: []const u8, ast: std.zig.Ast) void {
    @disableInstrumentation();
    var buf: [256]u8 = undefined;
    const ls = std.debug.lockStderr(&buf);
    defer std.debug.unlockStderr();
    logBadSourceInner(source, ls.terminal(), ast) catch {};
}

fn logBadSourceInner(source: []const u8, t: std.Io.Terminal, ast: std.zig.Ast) std.Io.Writer.Error!void {
    @disableInstrumentation();
    try logSourceInner(source, t);
    const w = t.writer;

    try w.writeAll("=== Parse Errors ===\n");
    for (ast.errors) |err| {
        const loc = ast.tokenLocation(0, err.token);
        try w.print("{}:{}: ", .{ loc.line + 1, loc.column + 1 });
        try ast.renderError(err, w);
        try w.writeByte('\n');
    }
}

pub fn logSource(source: []const u8) void {
    @disableInstrumentation();
    var buf: [256]u8 = undefined;
    const ls = std.debug.lockStderr(&buf);
    defer std.debug.unlockStderr();
    logSourceInner(source, ls.terminal()) catch {};
}

fn logSourceInner(source: []const u8, t: std.Io.Terminal) std.Io.Writer.Error!void {
    @disableInstrumentation();
    const w = t.writer;

    t.setColor(.dim) catch {};
    try w.writeAll("=== Source ===\n");
    t.setColor(.reset) catch {};

    var line: usize = 1;
    try w.print("{: >5} ", .{line});
    for (source) |c| switch (c) {
        ' '...0x7e => try w.writeByte(c),
        '\n' => {
            line += 1;
            try w.print("\n{: >5} ", .{line});
        },
        '\r' => {
            t.setColor(.cyan) catch {};
            try w.writeAll("\\r");
            t.setColor(.reset) catch {};
        },
        '\t' => {
            t.setColor(.cyan) catch {};
            try w.writeAll("\\t");
            t.setColor(.reset) catch {};
        },
        else => {
            t.setColor(.cyan) catch {};
            try w.print("\\x{x:0>2}", .{c});
            t.setColor(.reset) catch {};
        },
    };
    try w.writeByte('\n');
}