test "crypto.random.bytes" {
    var buf: [16]u8 = undefined;
    const crypto = @import("std").crypto;
    crypto.random.bytes(&buf);
}

test "crypto.sign.Ed25519.sign" {
    const std = @import("std");
    const testing = std.testing;
    const crypto = std.crypto;

    const kp = try crypto.sign.Ed25519.KeyPair.create(null);

    var msg = "abc";
    const sig: [64]u8 = try crypto.sign.Ed25519.sign(msg, kp, null);

    try crypto.sign.Ed25519.verify(sig, msg, kp.public_key);
    
    var bad_msg = "xyz";
    try testing.expectError(
        error.SignatureVerificationFailed,
        crypto.sign.Ed25519.verify(sig, bad_msg, kp.public_key),
    );
}

test "crypto.dh.X25519.scalarmult" {
    const std = @import("std");
    const testing = std.testing;
    const crypto = std.crypto;

    var seed1: [32]u8 = undefined;
    crypto.random.bytes(&seed1);

    var seed2: [32]u8 = undefined;
    crypto.random.bytes(&seed2);

    const kp1 = try crypto.sign.Ed25519.KeyPair.create(seed1);

    const kp2 = try crypto.sign.Ed25519.KeyPair.create(seed2);

    const xkp1 = try crypto.dh.X25519.KeyPair.fromEd25519(kp1);
    const xkp2 = try crypto.dh.X25519.KeyPair.fromEd25519(kp2);

    const pk1: [32]u8 = try crypto.dh.X25519.publicKeyFromEd25519(kp1.public_key);
    const pk2: [32]u8 = try crypto.dh.X25519.publicKeyFromEd25519(kp2.public_key);

    const o1 = try crypto.dh.X25519.scalarmult(xkp1.secret_key, pk2);
    const o2 = try crypto.dh.X25519.scalarmult(xkp2.secret_key, pk1);

    try testing.expectEqual(o1, o2);
}

const std = @import("std");
const crypto = std.crypto;
const testing = std.testing;

const Aes256Gcm = std.crypto.aead.aes_gcm.Aes256Gcm;

test "Aes256Gcm - Message and associated data" {
    const key: [Aes256Gcm.key_length]u8 = [_]u8{0x00} ** Aes256Gcm.key_length;
    const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x00} ** Aes256Gcm.nonce_length;
    const text = "Test with message";
    const ad = "Test with associated data";

    var cipher_text: [text.len]u8 = undefined;
    var plain_text: [text.len]u8 = undefined;
    var tag: [Aes256Gcm.tag_length]u8 = undefined;

    Aes256Gcm.encrypt(&cipher_text, &tag, text, ad, nonce, key);
    try Aes256Gcm.decrypt(&plain_text, &cipher_text, tag, ad, nonce, key);
    try testing.expectEqualSlices(u8, text[0..], plain_text[0..]);
}

$ zig init-exe
info: Created build.zig
info: Created src/main.zig
info: Next, try `zig build --help` or `zig build run`
$ zig build run
info: All your codebase are belong to us.
$ ./zig-out/bin/spam
info: All your codebase are belong to us.

$ zig test src/main.zig
All 1 tests passed.

const std = @import("std");
const Allocator = std.mem.Allocator;
const expect = std.testing.expect;

test "using an allocator" {
    var buffer: [100]u8 = undefined;
    const allocator = std.heap.FixedBufferAllocator.init(&buffer).allocator();
    const result = try concat(allocator, "foo", "bar");
    try expect(std.mem.eql(u8, "foobar", result));
}

fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {
    const result = try allocator.alloc(u8, a.len + b.len);
    std.mem.copy(u8, result, a);
    std.mem.copy(u8, result[a.len..], b);
    return result;
}

fn foo(s: []u8) void {
    _ = s;
}

test "string literal to mutable slice" {
    foo("hello");
}

fn foo(s: []const u8) void {
    _ = s;
}

test "string literal to constant slice" {
    foo("hello");
}

const hex = "160303";
var buf: [hex.len / 2]u8 = undefined;
const data = try std.fmt.hexToBytes(buf[0..], hex);
std.debug.print("{s}\n", .{std.fmt.fmtSliceHexUpper(data)});

test "readBits" {
    // zig fmt: off
    const recv_data = [_]u8{
        0x80, 0x64, 0x00, 0x01,
    };

    // zig fmt: on
    var fbs = std.io.fixedBufferStream(&recv_data);
    var bit_stream = std.io.bitReader(.Big, fbs.reader());
    var out_bits: usize = undefined;
    const version = try bit_stream.readBits(u2, 2, &out_bits);

    try testing.expectEqual(2, header.version);
}

// Little Endian 前提のコード
pub const RtpHeader = packed struct(u8) {
    csrc_count: u4,
    extension: u1,
    padding: u1,
    version: u2,
};

test "packed struct @bitCast" {
    // zig fmt: off
    const recv_data = [_]u8{
        0x80, 0x64, 0x00, 0x01,
    };

    // zig fmt: on
    var fbs = std.io.fixedBufferStream(&recv_data);
    var reader = fbs.reader();
    const raw_header = try reader.readIntBig(u8);
    const header = @bitCast(RtpHeader, raw_header);

    try testing.expectEqual(2, header.version);
}

const std = @import("std");
var counter = std.atomic.Atomic(u64).init(0);

pub fn main() !void {
    // 戻り値は変更前の値
    _ = counter.fetchAdd(1, .SeqCst);
    const count = counter.load(.SeqCst);
}

const std = @import("std");
const ThreadPool = std.Thread.Pool;
const Queue = std.atomic.Queue;
const Node = std.atomic.Queue([]const u8).Node;

// キューはグローバルに置く
var queue = std.atomic.Queue([]const u8).init();
// カウンターもグローバルに置く
// カウンターこれ一つ一つ定義しないとダメなのか
var counter = std.atomic.Atomic(u64).init(0);

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    var allocator = gpa.allocator();

    var thread_pool: ThreadPool = undefined;
    try thread_pool.init(.{ .allocator = allocator });
    defer thread_pool.deinit();

    var line_buffer: [256]u8 = undefined;
    while (true) {
        // ここでブロックしてる
        const buffer_size = try std.io.getStdIn().read(&line_buffer);

        // キューに追加するための node を用意
        const node = allocator.create(Node) catch unreachable;
        // お作法
        node.* = .{
            .prev = undefined,
            .next = undefined,
            .data = line_buffer[0..buffer_size],
        };

        // キューへ追加
        queue.put(node);

        try thread_pool.spawn(runTask, .{&allocator});
    }
}

fn runTask(allocator: *std.mem.Allocator) void {
    const node = queue.get() orelse return;
    // キューからノードを取り出して、表示
    std.debug.print("node.data={s}", .{node.data});
    // fetchAdd の戻りは前の値
    _ = counter.fetchAdd(1, .SeqCst);
    // 今の値を取りたいので load で今の値を取得する
    const count = counter.load(.SeqCst);
    // 処理数をプリント
    std.debug.print("count={d}\n", .{count});
    // queue はメモリを管理してくれないので、取得したやつが破棄する
    allocator.destroy(node);
}