var data = {lines:[
{"lineNum":"    1","line":"const std = @import(\"std\");"},
{"lineNum":"    2","line":"const builtin = @import(\"builtin\");"},
{"lineNum":"    3","line":"const assert = std.debug.assert;"},
{"lineNum":"    4","line":"const mem = std.mem;"},
{"lineNum":"    5","line":"const meta = std.meta;"},
{"lineNum":"    6","line":""},
{"lineNum":"    7","line":"/// Describes how pointer types should be hashed."},
{"lineNum":"    8","line":"pub const HashStrategy = enum {"},
{"lineNum":"    9","line":"    /// Do not follow pointers, only hash their value."},
{"lineNum":"   10","line":"    Shallow,"},
{"lineNum":"   11","line":""},
{"lineNum":"   12","line":"    /// Follow pointers, hash the pointee content."},
{"lineNum":"   13","line":"    /// Only dereferences one level, ie. it is changed into .Shallow when a"},
{"lineNum":"   14","line":"    /// pointer type is encountered."},
{"lineNum":"   15","line":"    Deep,"},
{"lineNum":"   16","line":""},
{"lineNum":"   17","line":"    /// Follow pointers, hash the pointee content."},
{"lineNum":"   18","line":"    /// Dereferences all pointers encountered."},
{"lineNum":"   19","line":"    /// Assumes no cycle."},
{"lineNum":"   20","line":"    DeepRecursive,"},
{"lineNum":"   21","line":"};"},
{"lineNum":"   22","line":""},
{"lineNum":"   23","line":"/// Helper function to hash a pointer and mutate the strategy if needed."},
{"lineNum":"   24","line":"pub fn hashPointer(hasher: var, key: var, comptime strat: HashStrategy) void {","class":"lineCov","hits":"4","order":"13573","possible_hits":"4",},
{"lineNum":"   25","line":"    const info = @typeInfo(@TypeOf(key));"},
{"lineNum":"   26","line":""},
{"lineNum":"   27","line":"    switch (info.Pointer.size) {"},
{"lineNum":"   28","line":"        .One => switch (strat) {"},
{"lineNum":"   29","line":"            .Shallow => hash(hasher, @ptrToInt(key), .Shallow),","class":"lineCov","hits":"3","order":"13544","possible_hits":"3",},
{"lineNum":"   30","line":"            .Deep => hash(hasher, key.*, .Shallow),","class":"lineCov","hits":"6","order":"13552","possible_hits":"6",},
{"lineNum":"   31","line":"            .DeepRecursive => hash(hasher, key.*, .DeepRecursive),","class":"lineCov","hits":"3","order":"13560","possible_hits":"3",},
{"lineNum":"   32","line":"        },"},
{"lineNum":"   33","line":""},
{"lineNum":"   34","line":"        .Slice => switch (strat) {"},
{"lineNum":"   35","line":"            .Shallow => {"},
{"lineNum":"   36","line":"                hashPointer(hasher, key.ptr, .Shallow);","class":"lineCov","hits":"2","order":"13572","possible_hits":"2",},
{"lineNum":"   37","line":"                hash(hasher, key.len, .Shallow);","class":"lineCov","hits":"2","order":"13575","possible_hits":"2",},
{"lineNum":"   38","line":"            },"},
{"lineNum":"   39","line":"            .Deep => hashArray(hasher, key, .Shallow),"},
{"lineNum":"   40","line":"            .DeepRecursive => hashArray(hasher, key, .DeepRecursive),"},
{"lineNum":"   41","line":"        },"},
{"lineNum":"   42","line":""},
{"lineNum":"   43","line":"        .Many,"},
{"lineNum":"   44","line":"        .C,"},
{"lineNum":"   45","line":"        => switch (strat) {"},
{"lineNum":"   46","line":"            .Shallow => hash(hasher, @ptrToInt(key), .Shallow),","class":"lineCov","hits":"2","order":"13574","possible_hits":"2",},
{"lineNum":"   47","line":"            else => @compileError("},
{"lineNum":"   48","line":"                \\\\ unknown-length pointers and C pointers cannot be hashed deeply."},
{"lineNum":"   49","line":"                \\\\ Consider providing your own hash function."},
{"lineNum":"   50","line":"            ),"},
{"lineNum":"   51","line":"        },"},
{"lineNum":"   52","line":"    }"},
{"lineNum":"   53","line":"}"},
{"lineNum":"   54","line":""},
{"lineNum":"   55","line":"/// Helper function to hash a set of contiguous objects, from an array or slice."},
{"lineNum":"   56","line":"pub fn hashArray(hasher: var, key: var, comptime strat: HashStrategy) void {","class":"lineCov","hits":"4","order":"13587","possible_hits":"4",},
{"lineNum":"   57","line":"    switch (strat) {"},
{"lineNum":"   58","line":"        .Shallow => {"},
{"lineNum":"   59","line":"            // TODO detect via a trait when Key has no padding bits to"},
{"lineNum":"   60","line":"            // hash it as an array of bytes."},
{"lineNum":"   61","line":"            // Otherwise, hash every element."},
{"lineNum":"   62","line":"            for (key) |element| {","class":"lineCov","hits":"4","order":"13588","possible_hits":"4",},
{"lineNum":"   63","line":"                hash(hasher, element, .Shallow);","class":"lineCov","hits":"2","order":"13589","possible_hits":"2",},
{"lineNum":"   64","line":"            }"},
{"lineNum":"   65","line":"        },"},
{"lineNum":"   66","line":"        else => {"},
{"lineNum":"   67","line":"            for (key) |element| {"},
{"lineNum":"   68","line":"                hash(hasher, element, strat);"},
{"lineNum":"   69","line":"            }"},
{"lineNum":"   70","line":"        },"},
{"lineNum":"   71","line":"    }"},
{"lineNum":"   72","line":"}"},
{"lineNum":"   73","line":""},
{"lineNum":"   74","line":"/// Provides generic hashing for any eligible type."},
{"lineNum":"   75","line":"/// Strategy is provided to determine if pointers should be followed or not."},
{"lineNum":"   76","line":"pub fn hash(hasher: var, key: var, comptime strat: HashStrategy) void {","class":"lineCov","hits":"93","order":"4736","possible_hits":"93",},
{"lineNum":"   77","line":"    const Key = @TypeOf(key);"},
{"lineNum":"   78","line":"    switch (@typeInfo(Key)) {"},
{"lineNum":"   79","line":"        .NoReturn,"},
{"lineNum":"   80","line":"        .Opaque,"},
{"lineNum":"   81","line":"        .Undefined,"},
{"lineNum":"   82","line":"        .Void,"},
{"lineNum":"   83","line":"        .Null,"},
{"lineNum":"   84","line":"        .BoundFn,"},
{"lineNum":"   85","line":"        .ComptimeFloat,"},
{"lineNum":"   86","line":"        .ComptimeInt,"},
{"lineNum":"   87","line":"        .Type,"},
{"lineNum":"   88","line":"        .EnumLiteral,"},
{"lineNum":"   89","line":"        .Frame,"},
{"lineNum":"   90","line":"        => @compileError(\"cannot hash this type\"),"},
{"lineNum":"   91","line":""},
{"lineNum":"   92","line":"        // Help the optimizer see that hashing an int is easy by inlining!"},
{"lineNum":"   93","line":"        // TODO Check if the situation is better after #561 is resolved."},
{"lineNum":"   94","line":"        .Int => @call(.{ .modifier = .always_inline }, hasher.update, .{std.mem.asBytes(&key)}),","class":"lineCov","hits":"13","order":"4737","possible_hits":"13",},
{"lineNum":"   95","line":""},
{"lineNum":"   96","line":"        .Float => |info| hash(hasher, @bitCast(std.meta.Int(false, info.bits), key), strat),","class":"lineCov","hits":"4","order":"13604","possible_hits":"4",},
{"lineNum":"   97","line":""},
{"lineNum":"   98","line":"        .Bool => hash(hasher, @boolToInt(key), strat),","class":"lineCov","hits":"2","order":"13605","possible_hits":"2",},
{"lineNum":"   99","line":"        .Enum => hash(hasher, @enumToInt(key), strat),","class":"lineCov","hits":"1","order":"13648","possible_hits":"1",},
{"lineNum":"  100","line":"        .ErrorSet => hash(hasher, @errorToInt(key), strat),","class":"lineCov","hits":"1","order":"13667","possible_hits":"1",},
{"lineNum":"  101","line":"        .AnyFrame, .Fn => hash(hasher, @ptrToInt(key), strat),"},
{"lineNum":"  102","line":""},
{"lineNum":"  103","line":"        .Pointer => @call(.{ .modifier = .always_inline }, hashPointer, .{ hasher, key, strat }),","class":"lineCov","hits":"14","order":"13543","possible_hits":"14",},
{"lineNum":"  104","line":""},
{"lineNum":"  105","line":"        .Optional => if (key) |k| hash(hasher, k, strat),","class":"lineCov","hits":"1","order":"13625","possible_hits":"1",},
{"lineNum":"  106","line":""},
{"lineNum":"  107","line":"        .Array => hashArray(hasher, key, strat),","class":"lineCov","hits":"2","order":"13586","possible_hits":"2",},
{"lineNum":"  108","line":""},
{"lineNum":"  109","line":"        .Vector => |info| {"},
{"lineNum":"  110","line":"            if (info.child.bit_count % 8 == 0) {"},
{"lineNum":"  111","line":"                // If there\'s no unused bits in the child type, we can just hash"},
{"lineNum":"  112","line":"                // this as an array of bytes."},
{"lineNum":"  113","line":"                hasher.update(mem.asBytes(&key));","class":"lineCov","hits":"1","order":"13658","possible_hits":"1",},
{"lineNum":"  114","line":"            } else {"},
{"lineNum":"  115","line":"                // Otherwise, hash every element."},
{"lineNum":"  116","line":"                comptime var i = 0;"},
{"lineNum":"  117","line":"                inline while (i < info.len) : (i += 1) {"},
{"lineNum":"  118","line":"                    hash(hasher, key[i], strat);","class":"lineCov","hits":"1","order":"13661","possible_hits":"1",},
{"lineNum":"  119","line":"                }"},
{"lineNum":"  120","line":"            }"},
{"lineNum":"  121","line":"        },"},
{"lineNum":"  122","line":""},
{"lineNum":"  123","line":"        .Struct => |info| {"},
{"lineNum":"  124","line":"            // TODO detect via a trait when Key has no padding bits to"},
{"lineNum":"  125","line":"            // hash it as an array of bytes."},
{"lineNum":"  126","line":"            // Otherwise, hash every field."},
{"lineNum":"  127","line":"            inline for (info.fields) |field| {"},
{"lineNum":"  128","line":"                // We reuse the hash of the previous field as the seed for the"},
{"lineNum":"  129","line":"                // next one so that they\'re dependant."},
{"lineNum":"  130","line":"                hash(hasher, @field(key, field.name), strat);","class":"lineCov","hits":"5","order":"13603","possible_hits":"5",},
{"lineNum":"  131","line":"            }"},
{"lineNum":"  132","line":"        },"},
{"lineNum":"  133","line":""},
{"lineNum":"  134","line":"        .Union => |info| blk: {"},
{"lineNum":"  135","line":"            if (info.tag_type) |tag_type| {"},
{"lineNum":"  136","line":"                const tag = meta.activeTag(key);","class":"lineCov","hits":"1","order":"13646","possible_hits":"1",},
{"lineNum":"  137","line":"                const s = hash(hasher, tag, strat);","class":"lineCov","hits":"1","order":"13647","possible_hits":"1",},
{"lineNum":"  138","line":"                inline for (info.fields) |field| {"},
{"lineNum":"  139","line":"                    const enum_field = field.enum_field.?;"},
{"lineNum":"  140","line":"                    if (enum_field.value == @enumToInt(tag)) {","class":"linePartCov","hits":"3","order":"13649","possible_hits":"4",},
{"lineNum":"  141","line":"                        hash(hasher, @field(key, enum_field.name), strat);","class":"linePartCov","hits":"4","order":"13650","possible_hits":"7",},
{"lineNum":"  142","line":"                        // TODO use a labelled break when it does not crash the compiler. cf #2908"},
{"lineNum":"  143","line":"                        // break :blk;"},
{"lineNum":"  144","line":"                        return;","class":"lineCov","hits":"3","order":"13651","possible_hits":"3",},
{"lineNum":"  145","line":"                    }"},
{"lineNum":"  146","line":"                }"},
{"lineNum":"  147","line":"                unreachable;","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  148","line":"            } else @compileError(\"cannot hash untagged union type: \" ++ @typeName(Key) ++ \", provide your own hash function\");"},
{"lineNum":"  149","line":"        },"},
{"lineNum":"  150","line":""},
{"lineNum":"  151","line":"        .ErrorUnion => blk: {"},
{"lineNum":"  152","line":"            const payload = key catch |err| {","class":"linePartCov","hits":"1","order":"13665","possible_hits":"2",},
{"lineNum":"  153","line":"                hash(hasher, err, strat);","class":"lineCov","hits":"1","order":"13666","possible_hits":"1",},
{"lineNum":"  154","line":"                break :blk;","class":"lineCov","hits":"1","order":"13668","possible_hits":"1",},
{"lineNum":"  155","line":"            };"},
{"lineNum":"  156","line":"            hash(hasher, payload, strat);","class":"lineNoCov","hits":"0","possible_hits":"1",},
{"lineNum":"  157","line":"        },"},
{"lineNum":"  158","line":"    }"},
{"lineNum":"  159","line":"}"},
{"lineNum":"  160","line":""},
{"lineNum":"  161","line":"/// Provides generic hashing for any eligible type."},
{"lineNum":"  162","line":"/// Only hashes `key` itself, pointers are not followed."},
{"lineNum":"  163","line":"/// Slices are rejected to avoid ambiguity on the user\'s intention."},
{"lineNum":"  164","line":"pub fn autoHash(hasher: var, key: var) void {","class":"linePartCov","hits":"8","order":"4734","possible_hits":"10",},
{"lineNum":"  165","line":"    const Key = @TypeOf(key);"},
{"lineNum":"  166","line":"    if (comptime meta.trait.isSlice(Key)) {"},
{"lineNum":"  167","line":"        comptime assert(@hasDecl(std, \"StringHashMap\")); // detect when the following message needs updated"},
{"lineNum":"  168","line":"        const extra_help = if (Key == []const u8)"},
{"lineNum":"  169","line":"            \" Consider std.StringHashMap for hashing the contents of []const u8.\""},
{"lineNum":"  170","line":"        else"},
{"lineNum":"  171","line":"            \"\";"},
{"lineNum":"  172","line":""},
{"lineNum":"  173","line":"        @compileError(\"std.auto_hash.autoHash does not allow slices (here \" ++ @typeName(Key) ++"},
{"lineNum":"  174","line":"            \") because the intent is unclear. Consider using std.auto_hash.hash or providing your own hash function instead.\" ++"},
{"lineNum":"  175","line":"            extra_help);"},
{"lineNum":"  176","line":"    }"},
{"lineNum":"  177","line":""},
{"lineNum":"  178","line":"    hash(hasher, key, .Shallow);","class":"linePartCov","hits":"4","order":"4735","possible_hits":"5",},
{"lineNum":"  179","line":"}"},
{"lineNum":"  180","line":""},
{"lineNum":"  181","line":"const testing = std.testing;"},
{"lineNum":"  182","line":"const Wyhash = std.hash.Wyhash;"},
{"lineNum":"  183","line":""},
{"lineNum":"  184","line":"fn testHash(key: var) u64 {","class":"lineCov","hits":"10","order":"13622","possible_hits":"10",},
{"lineNum":"  185","line":"    // Any hash could be used here, for testing autoHash."},
{"lineNum":"  186","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"10","order":"13623","possible_hits":"10",},
{"lineNum":"  187","line":"    hash(&hasher, key, .Shallow);","class":"lineCov","hits":"10","order":"13624","possible_hits":"10",},
{"lineNum":"  188","line":"    return hasher.final();","class":"lineCov","hits":"10","order":"13626","possible_hits":"10",},
{"lineNum":"  189","line":"}"},
{"lineNum":"  190","line":""},
{"lineNum":"  191","line":"fn testHashShallow(key: var) u64 {","class":"lineCov","hits":"4","order":"13540","possible_hits":"4",},
{"lineNum":"  192","line":"    // Any hash could be used here, for testing autoHash."},
{"lineNum":"  193","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"4","order":"13541","possible_hits":"4",},
{"lineNum":"  194","line":"    hash(&hasher, key, .Shallow);","class":"lineCov","hits":"4","order":"13542","possible_hits":"4",},
{"lineNum":"  195","line":"    return hasher.final();","class":"lineCov","hits":"4","order":"13545","possible_hits":"4",},
{"lineNum":"  196","line":"}"},
{"lineNum":"  197","line":""},
{"lineNum":"  198","line":"fn testHashDeep(key: var) u64 {","class":"lineCov","hits":"6","order":"13549","possible_hits":"6",},
{"lineNum":"  199","line":"    // Any hash could be used here, for testing autoHash."},
{"lineNum":"  200","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"6","order":"13550","possible_hits":"6",},
{"lineNum":"  201","line":"    hash(&hasher, key, .Deep);","class":"lineCov","hits":"6","order":"13551","possible_hits":"6",},
{"lineNum":"  202","line":"    return hasher.final();","class":"lineCov","hits":"6","order":"13553","possible_hits":"6",},
{"lineNum":"  203","line":"}"},
{"lineNum":"  204","line":""},
{"lineNum":"  205","line":"fn testHashDeepRecursive(key: var) u64 {","class":"lineCov","hits":"2","order":"13557","possible_hits":"2",},
{"lineNum":"  206","line":"    // Any hash could be used here, for testing autoHash."},
{"lineNum":"  207","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"2","order":"13558","possible_hits":"2",},
{"lineNum":"  208","line":"    hash(&hasher, key, .DeepRecursive);","class":"lineCov","hits":"2","order":"13559","possible_hits":"2",},
{"lineNum":"  209","line":"    return hasher.final();","class":"lineCov","hits":"2","order":"13561","possible_hits":"2",},
{"lineNum":"  210","line":"}"},
{"lineNum":"  211","line":""},
{"lineNum":"  212","line":"test \"hash pointer\" {","class":"lineCov","hits":"2","order":"13538","possible_hits":"2",},
{"lineNum":"  213","line":"    const array = [_]u32{ 123, 123, 123 };"},
{"lineNum":"  214","line":"    const a = &array[0];"},
{"lineNum":"  215","line":"    const b = &array[1];"},
{"lineNum":"  216","line":"    const c = &array[2];"},
{"lineNum":"  217","line":"    const d = a;"},
{"lineNum":"  218","line":""},
{"lineNum":"  219","line":"    testing.expect(testHashShallow(a) == testHashShallow(d));","class":"lineCov","hits":"1","order":"13539","possible_hits":"1",},
{"lineNum":"  220","line":"    testing.expect(testHashShallow(a) != testHashShallow(c));","class":"lineCov","hits":"1","order":"13546","possible_hits":"1",},
{"lineNum":"  221","line":"    testing.expect(testHashShallow(a) != testHashShallow(b));","class":"lineCov","hits":"1","order":"13547","possible_hits":"1",},
{"lineNum":"  222","line":""},
{"lineNum":"  223","line":"    testing.expect(testHashDeep(a) == testHashDeep(a));","class":"lineCov","hits":"1","order":"13548","possible_hits":"1",},
{"lineNum":"  224","line":"    testing.expect(testHashDeep(a) == testHashDeep(c));","class":"lineCov","hits":"1","order":"13554","possible_hits":"1",},
{"lineNum":"  225","line":"    testing.expect(testHashDeep(a) == testHashDeep(b));","class":"lineCov","hits":"1","order":"13555","possible_hits":"1",},
{"lineNum":"  226","line":""},
{"lineNum":"  227","line":"    testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(a));","class":"lineCov","hits":"1","order":"13556","possible_hits":"1",},
{"lineNum":"  228","line":"    testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(c));","class":"lineCov","hits":"1","order":"13562","possible_hits":"1",},
{"lineNum":"  229","line":"    testing.expect(testHashDeepRecursive(a) == testHashDeepRecursive(b));","class":"lineCov","hits":"1","order":"13563","possible_hits":"1",},
{"lineNum":"  230","line":"}"},
{"lineNum":"  231","line":""},
{"lineNum":"  232","line":"test \"hash slice shallow\" {","class":"lineCov","hits":"3","order":"13564","possible_hits":"3",},
{"lineNum":"  233","line":"    // Allocate one array dynamically so that we\'re assured it is not merged"},
{"lineNum":"  234","line":"    // with the other by the optimization passes."},
{"lineNum":"  235","line":"    const array1 = try std.testing.allocator.create([6]u32);","class":"lineCov","hits":"1","order":"13565","possible_hits":"1",},
{"lineNum":"  236","line":"    defer std.testing.allocator.destroy(array1);","class":"lineCov","hits":"1","order":"13579","possible_hits":"1",},
{"lineNum":"  237","line":"    array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };","class":"lineCov","hits":"1","order":"13566","possible_hits":"1",},
{"lineNum":"  238","line":"    const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };"},
{"lineNum":"  239","line":"    // TODO audit deep/shallow - maybe it has the wrong behavior with respect to array pointers and slices"},
{"lineNum":"  240","line":"    var runtime_zero: usize = 0;","class":"lineCov","hits":"1","order":"13567","possible_hits":"1",},
{"lineNum":"  241","line":"    const a = array1[runtime_zero..];","class":"lineCov","hits":"1","order":"13568","possible_hits":"1",},
{"lineNum":"  242","line":"    const b = array2[runtime_zero..];","class":"lineCov","hits":"1","order":"13569","possible_hits":"1",},
{"lineNum":"  243","line":"    const c = array1[runtime_zero..3];","class":"lineCov","hits":"1","order":"13570","possible_hits":"1",},
{"lineNum":"  244","line":"    testing.expect(testHashShallow(a) == testHashShallow(a));","class":"lineCov","hits":"1","order":"13571","possible_hits":"1",},
{"lineNum":"  245","line":"    testing.expect(testHashShallow(a) != testHashShallow(array1));","class":"lineCov","hits":"1","order":"13576","possible_hits":"1",},
{"lineNum":"  246","line":"    testing.expect(testHashShallow(a) != testHashShallow(b));","class":"lineCov","hits":"1","order":"13577","possible_hits":"1",},
{"lineNum":"  247","line":"    testing.expect(testHashShallow(a) != testHashShallow(c));","class":"lineCov","hits":"1","order":"13578","possible_hits":"1",},
{"lineNum":"  248","line":"}"},
{"lineNum":"  249","line":""},
{"lineNum":"  250","line":"test \"hash slice deep\" {","class":"lineCov","hits":"3","order":"13580","possible_hits":"3",},
{"lineNum":"  251","line":"    // Allocate one array dynamically so that we\'re assured it is not merged"},
{"lineNum":"  252","line":"    // with the other by the optimization passes."},
{"lineNum":"  253","line":"    const array1 = try std.testing.allocator.create([6]u32);","class":"lineCov","hits":"1","order":"13581","possible_hits":"1",},
{"lineNum":"  254","line":"    defer std.testing.allocator.destroy(array1);","class":"lineCov","hits":"1","order":"13593","possible_hits":"1",},
{"lineNum":"  255","line":"    array1.* = [_]u32{ 1, 2, 3, 4, 5, 6 };","class":"lineCov","hits":"1","order":"13582","possible_hits":"1",},
{"lineNum":"  256","line":"    const array2 = [_]u32{ 1, 2, 3, 4, 5, 6 };"},
{"lineNum":"  257","line":"    const a = array1[0..];","class":"lineCov","hits":"1","order":"13583","possible_hits":"1",},
{"lineNum":"  258","line":"    const b = array2[0..];"},
{"lineNum":"  259","line":"    const c = array1[0..3];","class":"lineCov","hits":"1","order":"13584","possible_hits":"1",},
{"lineNum":"  260","line":"    testing.expect(testHashDeep(a) == testHashDeep(a));","class":"lineCov","hits":"1","order":"13585","possible_hits":"1",},
{"lineNum":"  261","line":"    testing.expect(testHashDeep(a) == testHashDeep(array1));","class":"lineCov","hits":"1","order":"13590","possible_hits":"1",},
{"lineNum":"  262","line":"    testing.expect(testHashDeep(a) == testHashDeep(b));","class":"lineCov","hits":"1","order":"13591","possible_hits":"1",},
{"lineNum":"  263","line":"    testing.expect(testHashDeep(a) != testHashDeep(c));","class":"lineCov","hits":"1","order":"13592","possible_hits":"1",},
{"lineNum":"  264","line":"}"},
{"lineNum":"  265","line":""},
{"lineNum":"  266","line":"test \"hash struct deep\" {","class":"lineCov","hits":"3","order":"13594","possible_hits":"3",},
{"lineNum":"  267","line":"    const Foo = struct {"},
{"lineNum":"  268","line":"        a: u32,"},
{"lineNum":"  269","line":"        b: f64,"},
{"lineNum":"  270","line":"        c: *bool,"},
{"lineNum":"  271","line":""},
{"lineNum":"  272","line":"        const Self = @This();"},
{"lineNum":"  273","line":""},
{"lineNum":"  274","line":"        pub fn init(allocator: *mem.Allocator, a_: u32, b_: f64, c_: bool) !Self {","class":"lineCov","hits":"1","order":"13596","possible_hits":"1",},
{"lineNum":"  275","line":"            const ptr = try allocator.create(bool);","class":"lineCov","hits":"1","order":"13597","possible_hits":"1",},
{"lineNum":"  276","line":"            ptr.* = c_;","class":"lineCov","hits":"1","order":"13598","possible_hits":"1",},
{"lineNum":"  277","line":"            return Self{ .a = a_, .b = b_, .c = ptr };","class":"lineCov","hits":"1","order":"13599","possible_hits":"1",},
{"lineNum":"  278","line":"        }"},
{"lineNum":"  279","line":"    };"},
{"lineNum":"  280","line":""},
{"lineNum":"  281","line":"    const allocator = std.testing.allocator;"},
{"lineNum":"  282","line":"    const foo = try Foo.init(allocator, 123, 1.0, true);","class":"lineCov","hits":"1","order":"13595","possible_hits":"1",},
{"lineNum":"  283","line":"    const bar = try Foo.init(allocator, 123, 1.0, true);","class":"lineCov","hits":"1","order":"13600","possible_hits":"1",},
{"lineNum":"  284","line":"    const baz = try Foo.init(allocator, 123, 1.0, false);","class":"lineCov","hits":"1","order":"13601","possible_hits":"1",},
{"lineNum":"  285","line":"    defer allocator.destroy(foo.c);","class":"lineCov","hits":"1","order":"13619","possible_hits":"1",},
{"lineNum":"  286","line":"    defer allocator.destroy(bar.c);","class":"lineCov","hits":"1","order":"13618","possible_hits":"1",},
{"lineNum":"  287","line":"    defer allocator.destroy(baz.c);","class":"lineCov","hits":"1","order":"13617","possible_hits":"1",},
{"lineNum":"  288","line":""},
{"lineNum":"  289","line":"    testing.expect(testHashDeep(foo) == testHashDeep(bar));","class":"lineCov","hits":"1","order":"13602","possible_hits":"1",},
{"lineNum":"  290","line":"    testing.expect(testHashDeep(foo) != testHashDeep(baz));","class":"lineCov","hits":"1","order":"13606","possible_hits":"1",},
{"lineNum":"  291","line":"    testing.expect(testHashDeep(bar) != testHashDeep(baz));","class":"lineCov","hits":"1","order":"13607","possible_hits":"1",},
{"lineNum":"  292","line":""},
{"lineNum":"  293","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"1","order":"13608","possible_hits":"1",},
{"lineNum":"  294","line":"    const h = testHashDeep(foo);","class":"lineCov","hits":"1","order":"13609","possible_hits":"1",},
{"lineNum":"  295","line":"    autoHash(&hasher, foo.a);","class":"lineCov","hits":"1","order":"13610","possible_hits":"1",},
{"lineNum":"  296","line":"    autoHash(&hasher, foo.b);","class":"lineCov","hits":"1","order":"13611","possible_hits":"1",},
{"lineNum":"  297","line":"    autoHash(&hasher, foo.c.*);","class":"lineCov","hits":"1","order":"13612","possible_hits":"1",},
{"lineNum":"  298","line":"    testing.expectEqual(h, hasher.final());","class":"lineCov","hits":"1","order":"13613","possible_hits":"1",},
{"lineNum":"  299","line":""},
{"lineNum":"  300","line":"    const h2 = testHashDeepRecursive(&foo);","class":"lineCov","hits":"1","order":"13614","possible_hits":"1",},
{"lineNum":"  301","line":"    testing.expect(h2 != testHashDeep(&foo));","class":"lineCov","hits":"1","order":"13615","possible_hits":"1",},
{"lineNum":"  302","line":"    testing.expect(h2 == testHashDeep(foo));","class":"lineCov","hits":"1","order":"13616","possible_hits":"1",},
{"lineNum":"  303","line":"}"},
{"lineNum":"  304","line":""},
{"lineNum":"  305","line":"test \"testHash optional\" {","class":"lineCov","hits":"2","order":"13620","possible_hits":"2",},
{"lineNum":"  306","line":"    const a: ?u32 = 123;"},
{"lineNum":"  307","line":"    const b: ?u32 = null;"},
{"lineNum":"  308","line":"    testing.expectEqual(testHash(a), testHash(@as(u32, 123)));","class":"lineCov","hits":"1","order":"13621","possible_hits":"1",},
{"lineNum":"  309","line":"    testing.expect(testHash(a) != testHash(b));","class":"lineCov","hits":"1","order":"13627","possible_hits":"1",},
{"lineNum":"  310","line":"    testing.expectEqual(testHash(b), 0);","class":"lineCov","hits":"1","order":"13628","possible_hits":"1",},
{"lineNum":"  311","line":"}"},
{"lineNum":"  312","line":""},
{"lineNum":"  313","line":"test \"testHash array\" {","class":"lineCov","hits":"2","order":"13629","possible_hits":"2",},
{"lineNum":"  314","line":"    const a = [_]u32{ 1, 2, 3 };"},
{"lineNum":"  315","line":"    const h = testHash(a);","class":"lineCov","hits":"1","order":"13630","possible_hits":"1",},
{"lineNum":"  316","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"1","order":"13631","possible_hits":"1",},
{"lineNum":"  317","line":"    autoHash(&hasher, @as(u32, 1));","class":"lineCov","hits":"1","order":"13632","possible_hits":"1",},
{"lineNum":"  318","line":"    autoHash(&hasher, @as(u32, 2));","class":"lineCov","hits":"1","order":"13633","possible_hits":"1",},
{"lineNum":"  319","line":"    autoHash(&hasher, @as(u32, 3));","class":"lineCov","hits":"1","order":"13634","possible_hits":"1",},
{"lineNum":"  320","line":"    testing.expectEqual(h, hasher.final());","class":"lineCov","hits":"1","order":"13635","possible_hits":"1",},
{"lineNum":"  321","line":"}"},
{"lineNum":"  322","line":""},
{"lineNum":"  323","line":"test \"testHash struct\" {","class":"lineCov","hits":"2","order":"13636","possible_hits":"2",},
{"lineNum":"  324","line":"    const Foo = struct {"},
{"lineNum":"  325","line":"        a: u32 = 1,"},
{"lineNum":"  326","line":"        b: u32 = 2,"},
{"lineNum":"  327","line":"        c: u32 = 3,"},
{"lineNum":"  328","line":"    };"},
{"lineNum":"  329","line":"    const f = Foo{};"},
{"lineNum":"  330","line":"    const h = testHash(f);","class":"lineCov","hits":"1","order":"13637","possible_hits":"1",},
{"lineNum":"  331","line":"    var hasher = Wyhash.init(0);","class":"lineCov","hits":"1","order":"13638","possible_hits":"1",},
{"lineNum":"  332","line":"    autoHash(&hasher, @as(u32, 1));","class":"lineCov","hits":"1","order":"13639","possible_hits":"1",},
{"lineNum":"  333","line":"    autoHash(&hasher, @as(u32, 2));","class":"lineCov","hits":"1","order":"13640","possible_hits":"1",},
{"lineNum":"  334","line":"    autoHash(&hasher, @as(u32, 3));","class":"lineCov","hits":"1","order":"13641","possible_hits":"1",},
{"lineNum":"  335","line":"    testing.expectEqual(h, hasher.final());","class":"lineCov","hits":"1","order":"13642","possible_hits":"1",},
{"lineNum":"  336","line":"}"},
{"lineNum":"  337","line":""},
{"lineNum":"  338","line":"test \"testHash union\" {","class":"lineCov","hits":"2","order":"13643","possible_hits":"2",},
{"lineNum":"  339","line":"    const Foo = union(enum) {"},
{"lineNum":"  340","line":"        A: u32,"},
{"lineNum":"  341","line":"        B: f32,"},
{"lineNum":"  342","line":"        C: u32,"},
{"lineNum":"  343","line":"    };"},
{"lineNum":"  344","line":""},
{"lineNum":"  345","line":"    const a = Foo{ .A = 18 };"},
{"lineNum":"  346","line":"    var b = Foo{ .B = 12.34 };","class":"lineCov","hits":"1","order":"13644","possible_hits":"1",},
{"lineNum":"  347","line":"    const c = Foo{ .C = 18 };"},
{"lineNum":"  348","line":"    testing.expect(testHash(a) == testHash(a));","class":"lineCov","hits":"1","order":"13645","possible_hits":"1",},
{"lineNum":"  349","line":"    testing.expect(testHash(a) != testHash(b));","class":"lineCov","hits":"1","order":"13652","possible_hits":"1",},
{"lineNum":"  350","line":"    testing.expect(testHash(a) != testHash(c));","class":"lineCov","hits":"1","order":"13653","possible_hits":"1",},
{"lineNum":"  351","line":""},
{"lineNum":"  352","line":"    b = Foo{ .A = 18 };","class":"lineCov","hits":"1","order":"13654","possible_hits":"1",},
{"lineNum":"  353","line":"    testing.expect(testHash(a) == testHash(b));","class":"lineCov","hits":"1","order":"13655","possible_hits":"1",},
{"lineNum":"  354","line":"}"},
{"lineNum":"  355","line":""},
{"lineNum":"  356","line":"test \"testHash vector\" {","class":"lineCov","hits":"2","order":"13656","possible_hits":"2",},
{"lineNum":"  357","line":"    // Disabled because of #3317"},
{"lineNum":"  358","line":"    if (@import(\"builtin\").arch == .mipsel or @import(\"builtin\").arch == .mips) return error.SkipZigTest;"},
{"lineNum":"  359","line":""},
{"lineNum":"  360","line":"    const a: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };"},
{"lineNum":"  361","line":"    const b: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };"},
{"lineNum":"  362","line":"    testing.expect(testHash(a) == testHash(a));","class":"lineCov","hits":"1","order":"13657","possible_hits":"1",},
{"lineNum":"  363","line":"    testing.expect(testHash(a) != testHash(b));","class":"lineCov","hits":"1","order":"13659","possible_hits":"1",},
{"lineNum":"  364","line":""},
{"lineNum":"  365","line":"    const c: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 4 };"},
{"lineNum":"  366","line":"    const d: meta.Vector(4, u31) = [_]u31{ 1, 2, 3, 5 };"},
{"lineNum":"  367","line":"    testing.expect(testHash(c) == testHash(c));","class":"lineCov","hits":"1","order":"13660","possible_hits":"1",},
{"lineNum":"  368","line":"    testing.expect(testHash(c) != testHash(d));","class":"lineCov","hits":"1","order":"13662","possible_hits":"1",},
{"lineNum":"  369","line":"}"},
{"lineNum":"  370","line":""},
{"lineNum":"  371","line":"test \"testHash error union\" {","class":"lineCov","hits":"2","order":"13663","possible_hits":"2",},
{"lineNum":"  372","line":"    const Errors = error{Test};"},
{"lineNum":"  373","line":"    const Foo = struct {"},
{"lineNum":"  374","line":"        a: u32 = 1,"},
{"lineNum":"  375","line":"        b: u32 = 2,"},
{"lineNum":"  376","line":"        c: u32 = 3,"},
{"lineNum":"  377","line":"    };"},
{"lineNum":"  378","line":"    const f = Foo{};"},
{"lineNum":"  379","line":"    const g: Errors!Foo = Errors.Test;"},
{"lineNum":"  380","line":"    testing.expect(testHash(f) != testHash(g));","class":"lineCov","hits":"1","order":"13664","possible_hits":"1",},
{"lineNum":"  381","line":"    testing.expect(testHash(f) == testHash(Foo{}));","class":"lineCov","hits":"1","order":"13669","possible_hits":"1",},
{"lineNum":"  382","line":"    testing.expect(testHash(g) == testHash(Errors.Test));","class":"lineCov","hits":"1","order":"13670","possible_hits":"1",},
{"lineNum":"  383","line":"}"},
]};
var percent_low = 25;var percent_high = 75;
var header = { "command" : "test", "date" : "2020-05-19 01:29:25", "instrumented" : 139, "covered" : 137,};
var merged_data = [];