$ zig version
0.11.0-dev.38+b40fc7018

const print = @import("std").debug.print;
pub fn main() void {
    //this is comm
    print("Hello, world!\n", .{});
}

$ zig run run_hello.zig
Hello, world!

const print=@import("std").std.debug.print;
pub fn main() void{
    print("Hello 世界", .{});
}

D:\ziglearn>zig build-exe run_winutf8.zig
D:\ziglearn>run_winutf8
Hello 涓栫晫
D:\ziglearn>chcp
活动代码页: 936
D:\ziglearn>chcp 65001
Active code page: 65001
D:\ziglearn>run_winutf8
Hello 世界

const decimal_int=98222;
const hex_int=0xff;
const another_hex_int=0xFF;
const octal_int=0o755;
const binary_int=0b11110000;
const one_billion=1_000_000_000;
const binary_mask=0b1111_1100;
const permissions=0o7_5_5;

const floating_point=123.0E+77;
const another_float=123.0;
const another_float1=1234.02;
const yet_another=123.0e+77;
const hex_floating_point=0x103.70p-5;
const another_hex_float=0x103.70;
const nanosecond=0.000_000_001;

const print=@import("std").std.debug.print;
pub fn main() void{
    print("{} {}\n", .{'e' == '\x65',@TypeOf('e')});
    print("{X} {}\n",.{'语',@TypeOf('语')});
}

$ zig run run_char_literal.zig
true comptime_int
8BED comptime_int

const print=@import("std").std.debug.print;
pub fn main() void{
    const bytes = "hello";
    print("{}\n", .{@TypeOf(bytes)});
    print("{} {c} {}\n", .{bytes.len,bytes[1],bytes[5]});
    print("{}   {}\n",.{""[0],@TypeOf("")});
}

$ zig run run_string_literal.zig
*[5:0]u8
5 e 0
0   *const [0:0]u8

const mem = @import("std").mem;
const print=@import("std").std.debug.print;
pub fn main() void{
    print("{s} {}\n",.{"\xE8\xAF\xAD",@TypeOf("\xE8\xAF\xAD")});
    print("{X} {X} {X} {X}\n",.{"语"[0],"语"[1],"语"[2],"语"[3]});
    print("{}\n",.{mem.eql(u8,"语","\xE8\xAF\xAD")});
    const i='语';
    print("{X}\n",.{i});
}

$ zig run run_diff_char_string_literal.zig
语 *const [3:0]u8
E8 AF AD 0
true
8BED

const expect=@import("std").testing.expect;
test "single char equal to element" {
    const str="Zig语言";
    try expect(str[0]=='Z');
    try expect(str[2]=='g');
    try expect(str[3]!='语');
}

\n 10 0x0A LF(new line) 回车
\r 13 0x0D CR(carriage return) 换行
\t 09 0x09 HT(horizontal tab) 水平制表符
\\ 92 0x5C bask slash 反斜杠
\' 39 0x27 single quote 单引号
\" 34 0x22 double quote 双引号
\xNN 8位长的字节值（2个十六进制数字）
\u{NNNNNN} Unicode码点值（1个或多个十六进制数字）

const eql=@import("std").mem.eql;
const expect=@import("std").testing.expect;
test "escape sequence" {
    try expect(eql(u8,"hello","h\x65llo"));
    try expect(eql(u8,"--\x65--\u{8bed}--","--e--语--"));
}

const print=@import("std").std.debug.print;
pub fn main() void{
const c =
    \\#include <stdio.h>
    \\
    \\int main(int argc, char **argv) {
    \\    printf("hello world\n");
    \\    return 0;
    \\}
;
print("{}",.{c});
}

const mem=@import("std").mem;
const assert=@import("std").debug.assert;
pub fn main() !void {
    const m=[_]u8{'h','e'};
    const m1="he";
comptime{
    assert(m.len==2);
    assert(mem.eql(u8,&m,m1));
}
    var m2=[4]u16{15,290,30,400};
    assert(m2[1]==290);
    var m3:[3]u32=.{1,2,3};
    assert(m3[1]==2);
}

const expect=@import("std").testing.expect;
const foo=struct{x:u8, y:u64, var z:u64=5};
test "struct literal" {
    const f1=foo{.x=1, .y=260,};
    try expect(f1.y==260);
    const f2:foo=.{.x=2, .y=470};
    try expect(f2.x==2);
    var f3:foo=.{.x=3, .y=undefined};
    f3.y=50;
    try expect(f3.y==50);
}

const expect=@import("std").testing.expect;
fn dump(args:anytype) !void {
    try expect(args.@"0"==1234);
    try expect(args.@"1"==12.34);
    try expect(args.@"2");
    try expect(args.@"3"[1]=='i');
}
test "anonymous list literal" {
    try dump(.{@as(u32,1234),@as(f64,12.34),true,"hi"});
}
test "tuple" {
    const args=(.{@as(u32,1234),@as(f64,12.34),true,"hi"});
    try expect(args[0]==1234);
    try expect(args[1]==12.34);
    try expect(args[2]==true);
    try expect(args[3][1]=='i');
}
test "inline for tuple"{
    const t=(.{@as(u32,1234),@as(f64,12.34),true,"hi"});
    inline for(t) |v,i|{
        if(i!=2) continue;
        try expect(v);
    }
}

const expect=@import("std").testing.expect;
test "enum literal" {
    const foo=enum{ok,not_ok,};
    const f1=foo.ok;
    const f2:foo=.ok;
    try expect(f1==f2);
}

const expect=@import("std").testing.expect;
test "union literal" {
    const foo=union{i:i32,f:f64};
    const f1=foo{.i=15};
    try expect(f1.i==15);
    const f2:foo=.{.f=3.3};
    try expect(f2.f==3.3);
}

const c = @import("std").c;
const expectEqual=@import("std").testing.expectEqual;
pub extern "c" fn @"error"() void;
test "ID"{
    const i:i8=10;
    const @"最大月份值"=i+2; // unicode汉字作为标识符。
    try expectEqual(12,@"最大月份值");
}

pub const foo=struct{pub const x:i32=15; const y:i32=17;};
fn fn1() void{}
pub fn fn2() void{}
const z:i64=18;

const expect=@import("std").testing.expect;
const testp=@import("pubfile.zig");
test "test pub" {
    try expect(testp.foo.x==15);
    testp.fn2();
    // try expect(testp.foo.y==17);
    // testp.fn1();
    // try expect(testp.foo.z==18);
}

const s1=struct{x:i32,const y:i64=15;};
const i:i32=100;
fn foo() void{
    const k:i8=0; _=k;
}
test "filens" {
    var j:i32=16; _=j;
}

fn foo() void{
    const i:i8=0;
    comptime {
        const j:i32=1; _=j;
    }
    const s=struct{x:i64,y:i64,const z:i32=1;};
    const s1=s{.x=1,.y=2}; _=s1;
}
fn foo1() void{
    var i:bool=true;
    if(i){
        const s=struct{};
        const j:i32=17;
        if(j>0){
            const k=j+5;
        }
    }
}
const temp:i32=10;

var i:i32=5;
test "inside blocks"{
    const j:i8=1;
    var i:i8=10+j; _=i;
}

$ zig test test_shadow.zig
test_shadow.zig:4:6: error: local shadows declaration of 'i'
 var i:i8=10+j;
     ^
test_shadow.zig:1:1: note: declared here
var i:i32=5;
^~~~~~~~~~~

test "can same ID" {
    {
        const pi=3.14; _=pi;
    }
    {
        var pi:bool=true; _=pi;
    }
}

test "using std namespace" {
    const S=struct {
        usingnamespace @import("std");
    };
    try S.testing.expect(true);
}

pub usingnamespace @cImport({
    @cInclude("epoxy/gl.h");
    @cInclude("GLFW/glfw3.h");
    @cDefine("STBI_ONLY_PNG", "");
    @cDefine("STBI_NO_STDIO", "");
    @cInclude("stb_image.h");
});

const k:i32=1;
k+=1;

const expect=@import("std").debug.expect;
test "variable type" {
    // var k=5;
    const x:i32=15;
    var y=x+3;
    try expect(@TypeOf(y)=i32);
}

test "undefined" {
    // const k;
    var x:i32=undefined;
    x=3;
    _=x;
}

    const i:i32=5;
    // _=i;
}

1  x() x[] x.y x.* x.?
2  a!b
3  x{}
4  !x -x -%x ~x &x ?x
5  * / % ** *% *| ||
6  + - ++ +% -% +| -|
7  << >> <<|
8  & ^ | orelse catch
9  == != < > <= >=
10 and
11 or
12 = *= *%= *|= /= %= += +%= +|= -= -%= -|= <<= <<|= >>= &= ^= |=

const expect=@import("std").testing.expect;
test "expr and stat" {
    const i:i32=5;
    const j= if(i>10) true else false;
    if(j){
        try expect(j);
    }
}

const expect=@import("std").testing.expect;
test "block nesting and values" {
    const i={
        const j:i32=0;
        {
            const k=j+1;
            _=k;
        }
    };
    try expect(@TypeOf(i)==void);
}
test "labeled break from labeled block expression"{
    var y:i32=123;
    const x= blk: {
        y+=1;
        break :blk y;
    };
    try expect(x==124);
    try expect(y==124);
}

const expect=@import("std").testing.expect;
fn nop() void{}
fn add(a:i8,b:i8) i8{
    if (a==0) {return b;}
    return a+b;
}
test "functions"{
    const i=add(0,9);
    try expect(i==9);
    nop();
    const x:i8=10; const y:i8=20;
    try expect(add(x,y)==30);
}

fn test1(i:i32)void{
    i+=1;
}
fn test2(p:*i32)void{
    p.*+=10;
    var i:i32=1;
    p=&i;
}
test "change parameter"{
    var i:i32=0;
    test1(i);
    test2(&i);
}

$ zig test test_change_para.zig
zig test test_change_para.zig
test_change_para.zig:5:3: error: cannot assign to constant
 i+=1;
 ~^~~
test_change_para.zig:10:4: error: cannot assign to constant
 p=&i;
   ^~

const expect=@import("std").testing.expect;
fn add2(x:anytype) @TypeOf(x){
    return x+42;
}
test "fn type inference" {
    try expect(add2(1)==43);
    try expect(@TypeOf(add2(1))==comptime_int);
    var y:i64=2;
    try expect(add2(y)==44);
    try expect(@TypeOf(add2(y))==i64);
}

const std = @import("std");
const builtin = @import("builtin");
const native_arch = builtin.cpu.arch;
const expect = std.testing.expect;

const WINAPI: std.builtin.CallingConvention = if(native_arch==.i386) .Stdcall else .C;
extern "kernel32" fn ExitProcess(exit_code: u32) callconv(WINAPI) noreturn;
extern "c" fn atan2(a: f64, b: f64) f64;

export fn sub(a:i8, b:i8) i8{
    return a-b;
}
pub fn sub2(a:i8,b:i8) i8{
    return a - b;
}
fn _start() callconv(.Naked) noreturn {
    abort();
}
fn shiftl1(a:u32) callconv(.Inline) u32{
    return a<<1;
}
fn abort() noreturn {
    @setCold(true);
    while (true) {}
}
test "function specifier"{
    try expect(true);
}

const expect = @import("std").testing.expect;
test "noinline function call" {
    try expect(@call(.{},add,.{3, 9})==12);
}
fn add(a: i32, b: i32) i32 {
    return a+b;
}

pub const CallOptions = struct {
    modifier: Modifier = .auto,
    stack: ?[]align(std.Target.stack_align) u8 = null;
    pub const Modifier = enum {
        auto,
        async_kw,
        never_tail,
        never_inline,
        no_async,
        always_tail,
        always_inline,
        compile-time,
    };
};

const print=@import("std").debug.print;
pub fn main() void{
    {
        var x:i32=1;
        {
            var y=x+2; _=y;
        }
        x+=5; print("{}\n",.{x});
    }
    x=5;
}

$zig build-exe run_scope.zig
hello.zig:12:2: error: use of undeclared identifier 'x'
 x=5;
 ^

const expect=@import("std").testing.expect;
fn defer1() !i32{
    var a:i32=1;
    {
        defer a=2;
        a=1;
    }
    try expect(a==2);
    a = 5;
    return a;
}
test "defer basics" {
    try expect(try defer1()==5);
}

const print=@import("std").debug.print;
fn deferUnwind() void{
    defer {
        print("defer1 ", .{});
    }
    defer {
        print("defer2 ", .{});
    }
    if (false) {
        defer {
            print("defer3 ", .{});
        }
    }
}
pub fn main() void{
    deferUnwind(); // defer2 defer1
}

fn defreturn(i:*i32) bool{
    i.* +=1;
    defer return true;
}

error: cannot return from defer expression

const print=@import("std").debug.print;
fn deferError(i:bool) !void {
    print("{}: start of function\n", .{i});
    defer {
        print("{}: end of function\n", .{i});
    }
    errdefer {
        print("{}: encountered an error!\n", .{i});
    }
    if (i) {
        return error.DeferError;
    }
}
fn deferErrorCap() !void {
    errdefer |e| {
        print("the error is {s}\n", .{@errorName(e)});
    }
    return error.DeferError;
}
pub fn main() void{
    deferError(false) catch {};
    deferError(true) catch {};
    deferErrorCap() catch {};
}

false: start of function
false: end of function
true: start of function
true: encountered an error!
true: end of function
the error is DeferError

const std=@import("std");
const Alloc=std.mem.Allocator;
const talloc=std.testing.allocator;
const expectError=std.testing.expectError;
const foo=struct{i:i32};
fn creatfoo(a:Alloc,i:i32) !*foo{
    const f= getf: {
        var f=try a.create(foo);
        errdefer a.destroy(f);
        f.i=15;
        break :getf f;
    };
    //errdefer a.destroy(f);
    if(i>1000) return error.invalid;
    return f;
}
test "errdefer leap"{
    try expectError(error.invalid,creatfoo(talloc,1001));
}

$ zig test test_errdefer_leak.zig
Test [1/1] test.errdefer leap... [gpa] (err): memory address 0x23b060c0000 leaked:
All 1 tests passed.
1 errors were logged.
1 tests leaked memory.

const expect=@import("std").testing.expect;
test "local var" {
    var i:i32=5;
    {
        var j:i32=10;
        try expect(i!=j);
    }
    i=j;
    try expect(i==j);
}

$ zig test test_local_var.zig
test_local_var.zig:8:4: error: use of undeclared identifier 'j'
 i=j;
   ^

const expect=@import("std").testing.expect;
test "comptime var" {
    comptime var y:i32=1;
    y+=1;
    try expect(y==2);
    if (y!=2) {
        @compileError("wrong y value");
    }
}

const expect=@import("std").testing.expect;
test "not comptime local var" {
    var x:i32=1;
    x+=1;
    try expect(x==2);
    if (x!=2) {
        @compileError("wrong x value");
    }
}

pub const j=i+3;
const i:i32=1;
pub fn foo() void {}

const expect=@import("std").testing.expect;
const gvar=@import("global_var.zig");
test "global var"{
    try expect(gvar.j==4);
    gvar.foo();
}

const expect=@import("std").testing.expect;
test "file level var" {
    try expect(add1()==2);
    try expect(x==2);
    try expect(add2()==4);
    try expect(x==4);
}
fn add1() i32 {x+=1; return x;}
fn add2() i32 {x+=2; return x;}
var x:i32=1;

const expect = @import("std").testing.expect;
test "namespaced container level variable" {
    try expect(foo()==1235);
    try expect(foo()==1236);
}
const S=struct {
    var x:i32=1234;
};
fn foo() i32 {
    S.x+=1;
    return S.x;
}

const expect = @import("std").testing.expect;
test "static local variable" {
    try expect(foo()==1235);
    try expect(foo()==1236);
    try expect(foo1()==1235);
    try expect(foo1()==1235);
}
fn foo() i32 {
    const S=struct {
        var x:i32=1234;
    };
    S.x+=1;
    return S.x;
}
fn foo1() i32 {
    var x:i32=1234;
    x+=1;
    return x;
}

{var x1:i32=1234; x1+=1; return x1};
{var x2:i32=1234; x1+=2; return x2};

{const S=struct{var x:i32=1234;};
    S.x+=1; return S.x};
{S.x+=1; return S.x};

const assert = std.debug.assert;
threadlocal var x: i32 = 1234;
test "thread local storage" {
    const thread1 = try std.Thread.spawn(.{}, testTls, .{});
    const thread2 = try std.Thread.spawn(.{}, testTls, .{});
    testTls();
    thread1.join();
    thread2.join();
}
fn testTls() void {
    assert(x == 1234);
    x += 1;
    assert(x == 1235);
}

const expect=@import("std").testing.expect;
test "align value" {
    if (@import("builtin").target.cpu.arch == .x86_64) {
        try expect(4==@typeInfo(*i32).Pointer.alignment);
        try expect(8==@alignOf(*i32));
        try expect(8==@alignOf(*u8));
        try expect(4==@alignOf(i32));
        try expect(1==@alignOf(u8));
        var x:i64=1;
        try expect(8==@alignOf(@TypeOf(x)));
    }
}

const expect=@import("std").testing.expect;
fn noop() align(@sizeOf(usize)*2) void {}
test "set align" {
    var i:u8 align(4)=100;
    const j=&i;
    var m:u8=200; const n=&m;
    try expect(@TypeOf(j)==*align(4) u8);
    try expect(@TypeOf(n)==*u8);
    try expect(1==@alignOf(u8));
    try expect(@TypeOf(j)!=@TypeOf(n));
    try expect(@alignOf(@TypeOf(noop))==@alignOf(usize)*2);
    noop();
}

const expectEqual=@import("std").testing.expectEqual;
test "aligned struct fields" {
    const S=struct{a:u32 align(2),
        b:u32 align(64)};
    var foo = S{.a=1,.b=2 };
    try expectEqual(64, @alignOf(S));
    try expectEqual(*align(2) u32,@TypeOf(&foo.a));
    try expectEqual(*align(64) u32,@TypeOf(&foo.b));
}

const expect=@import("std").testing.expect;
test "omit ptr align" {
    var i:u16=1; var j:*u16=&i;
    const a=@alignOf(@TypeOf(i));
    try expect(a==2);
    try expect(*u16==*align(a) u16);
    try expect(@TypeOf(j)==*align(a) u16);
}

const print=@import("std").debug.print;
pub fn main() void{
    var x:u8 align(4) =100;
    var ptr=&x;
    print("{}\n",.{@TypeOf(ptr)}); // *align(4) u8
    var ptr1:*u8=ptr;
    print("{} {}\n",.{@TypeOf(ptr1),ptr1.*}); // *u8 100
}

const mem=@import("std").mem;
const expect=@import("std").testing.expect;
test "safe alignCast"{
    var a=[_]u32{0x11111111,0x22222222};
    const bytes=mem.sliceAsBytes(a[0..]);
    const s=bytes[0..4];
    const su=mem.bytesAsSlice(u32,@alignCast(4,s));
    try expect(su[0]==0x11111111);
}    
test "UB alignCast"{
    var a=[_]u32{0x11111111,0x22222222};
    const bytes=mem.sliceAsBytes(a[0..]);
    const s=bytes[1..5];
    const su=mem.bytesAsSlice(u32,@alignCast(4,s));
    try expect(su[0]==0x22111111);
    print("\n{x}\n",.{su[0]});
}

$ zig test --test-filter "safe alignCast" test_alignCast.zig
All 1 tests passed.
$ zig test --test-filter "UB alignCast" test_alignCast.zig
Test [1/1] test.UB alignCast... thread 5304 panic: incorrect alignment

const mem=@import("std").mem;
const expect=@import("std").testing.expect;
var a=[_]u32{0x11111111,0x22222222};
const bytes=mem.sliceAsBytes(a[0..]);
test "safe alignCast"{
    const s=bytes[0..4];
    const su=mem.bytesAsSlice(u32,@alignCast(4,s));
    try expect(su[0]==0x11111111);
}    
test "UB alignCast"{
    const s=bytes[1..5];
    const su=mem.bytesAsSlice(u32,@alignCast(4,s));
    try expect(su[0]==0x22111111);
    print("\n{x}\n",.{su[0]});
}

$ zig test test_alignCast1.zig
All 2 tests passed.

const print=@import("std").debug.print;
const math=@import("std").math;
pub fn main() void {
    print("{} {}\n",.{math.floatMax(f32),math.floatMin(f32)});
    print("{} {}\n",.{math.f32_max,math.f32_min});
    print("{} {}\n",.{math.maxInt(i8),math.minInt(i8)});
    print("{} {}\n",.{math.maxInt(u8),math.minInt(u8)});
    print("{} {}\n",.{math.maxInt(u3),math.minInt(u3)});
    print("{} {}\n",.{math.maxInt(i3),math.minInt(i3)});
}

3.40282346e+38 1.17549435e-38
3.4028234663852886e+38 1.1754943508222875e-38
127 -128
255 0
7 0
3 -4

二进制逢2进1，x的范围是0<=x<=1 ，1+0=1，1+1=10
十进制逢10进1，x的范围是0<=x<=9，1+9=10，3+9=10+2=12
十六进制逢16进1，x的范围是0<=x<=15，1+F=10，3+F=10+2=12
六十进制（比如分钟）逢60进1，x的范围是0<=x<=59，1+59=1小时0分，3+59=1小时2分

16 | 2684| 12=> C
   -------
16  | 167| 7 => 7
    ------
16   | 10| 10=> A
     -----
        0

const expect = @import("std").testing.expect;
test "normal add"{
    try expect((2+5)==7);
    try expect((2.3+5)==7.3);
}
test "add overflow"{
    var j:i8=127;
    try expect(128==(j+1));
}
test "add underflow"{
    var j:i8=-128;
    try expect(-129==(j-1));
}

$ zig test --test-filter "normal add" test_add.zig
All 1 tests passed.
$ zig test --test-filter "add overflow" test_add.zig
Test [1/1] test.add overflow... thread 18520 panic: integer overflow
$ zig test --test-filter "add underflow" test_add.zig
Test [1/1] test.add underflow... thread 18520 panic: integer overflow

const print=@import("std").std.debug.print;
pub fn main() void{
    var i:u8=255;
    print("{} {}",.{i+%1,i+%2}); // 0 1
    const j:i8=-128;
    const j1:i8=-1;
    print("{}",.{j+%j1,j+%(j1-1)}); // 127 126
}

const print=@import("std").std.debug.print;
pub fn main() void{
    var i:u8=255;
    print("{} {}",.{i+%1,i+%2}); // 255 255
    const j:i8=-128;
    const j1:i8=-1;
    print("{}",.{j+%j1,j+%(j1-1)}); // -128 -128
}

const print=@import("std").debug.print;
pub fn main() void{
    addi8(5,10);
    addi8(127,1);
    addi8(-128,-1);
}
fn addi8(a:i8,b:i8) void{
    var r:i8=undefined;
    var ptr=&r;
    if(@addWithOverflow(i8,a,b,ptr)){
        print("{}+{} overflow, overflow result={}\n",.{a,b,ptr.*});
    }else{
        print("{}+{} = {}\n",.{a,b,ptr.*});
    }    
}

$ zig run run_addwithoverflow.zig
5+10 = 15
127+1 overflow, overflow result=-128
-128+-1 overflow, overflow result= 127

const print=@import("std").std.debug.print;
pub fn main() void{
    var i:u8=0;
    print("{} {}",.{i-%1,i-%2}); // 255 254
    print("{} {}",.{i-|1,i-|2}); // 0 0
    const j:i8=-128;
    print("{} {}",.{i-%1,i-%2}); // 127 126
    print("{} {}",.{i-|1,i-|2}); // -128 -128
}

const print=@import("std").debug.print;
pub fn main() void{
    subi8(5,10);
    subi8(-128,1);
    subi8(127,-1);
}
fn subi8(a:i8,b:i8) void{
    var r:i8=undefined;
    var ptr=&r;
    if(@subWithOverflow(i8,a,b,ptr)){
        print("{}-{} overflow, overflow result={}\n",.{a,b,ptr.*});
    }else{
        print("{}-{} = {}\n",.{a,b,ptr.*});
    }    
}

$ zig run run_subwithoverflow.zig
5-10 = -5
-128-1 overflow, overflow result=127
127--1 overflow, overflow result=-128

const expect=@import("std").testing.expect;
test "negation overflow" {
    var i:i8=-5;
    var j=-i;
    try expect(j==5);
    i=-128;
    j=-i;
    _=j;
}

const expect=@import("std").testing.expect;
test "wrapping negation" {
    var i:i8=@import("std").math.minInt(i8);
    try expect(i==-128);
    var j=-%i;
    try expect(j==-128);
}

const print=@import("std").std.debug.print;
pub fn main() void{
    var i:u8=130;
    print("{}",.{i*%2}); // 4
    print("{}",.{i*|2}); // 255
    var j:i8=-70;
    print("{}",.{j*%2}); // 116
    print("{}",.{j*|2}); // -128
}

const print=@import("std").debug.print;
pub fn main() void{
    muli8(5,10);
    muli8(70,2);
    muli8(-70,2);
}
fn muli8(a:i8,b:i8) void{
    var r:i8=undefined;
    var ptr=&r;
    if(@mulWithOverflow(i8,a,b,ptr)){
        print("{}*{} overflow, overflow result={}\n",.{a,b,ptr.*});
    }else{
        print("{}*{} = {}\n",.{a,b,ptr.*});
    }    
}

$ zig run run_subwithoverflow.zig
5*10 = 50
70*2 overflow, overflow result=-116
-70*2 overflow, overflow result=116

test "div signed integer" {
    const i:i8=-6;
    _=i/2;
    var m:i8=-6;
    _=m/2;
}

$ zig test test_div_signed.zig
test_div_signed.zig:5:5: error: division with 'i8' and 'comptime_int': signed integers must use @divTrunc, @divFloor, or @divExact
 _=m/2;

const expect=@import("std").testing.expect;
test "quot is int and no rem"{
    try expect(@divExact(6.4,3.2)==2);
    try expect(@divExact(6,2)==3);
}
test "quot is float"{
    var i:f32=6.4;
    try expect(@divExact(i,2)==3.0);
}
test "have rem"{
    var i:i32=6;
    try expect(@divExact(i,4)==1);
}
test "use std"{
    var i:i8=try @import("std").math.divExact(i8,6,4);
    _=i;
}

$ zig test --test-filter "quot is int and no rem" test_divExact.zig
All 1 tests passed.

$ zig test --test-filter "quot is float" test_divExact.zig
All 1 tests passed.

$ zig test --test-filter "have rem" test_divExact.zig
Test [1/1] test.have rem... thread 10068 panic: exact division produced remainder

$ zig test --test-filter "use std" test_divExact.zig
Test [1/1] test.use std... FAIL (UnexpectedRemainder)
C:\zig0100\lib\std\math.zig:905:44: 0x7ff731fe10a7 in divExact__anon_2110 (test.exe.obj)
    if (result * denominator != numerator) return error.UnexpectedRemainder;
                                           ^
C:/dev/zig/test_divExact.zig:16:11: 0x7ff731fe11ed in test.use std (test.exe.obj)
        var i:i8=try @import("std").math.divExact(i8,6,4);
          ^
0 passed; 0 skipped; 1 failed.

const expect=@import("std").testing.expect;
test "divFloor"{
    try expect(@divFloor(6.4,3.1)==2);
    try expect(@divFloor(8,3)==2);
    try expect(@divFloor(-8,3)==-3);
    try expect(@divFloor(-6.4,3)==-3);
    const i:f32=try @import("std").math.divFloor(f32,-10.0,3.1);
    try expect(i==-4);
}

const expect=@import("std").testing.expect;
test "divTrunc"{
    try expect(@divTrunc(6.4,3.1)==2);
    try expect(@divTrunc(8,3)==2);
    try expect(@divTrunc(-8,3)==-2);
    try expect(@divTrunc(-6.4,3)==-2);
    const i:f32=try @import("std").math.divTrunc(f32,-10.0,3.1);
    try expect(i==-3);
}

const expect=@import("std").testing.expect;
test "mod"{
    try expect((5%2)==1);
    try expect((-5%-2)==0);
    try expect((6.4%3)==0.4);
}

const expect=@import("std").testing.expect;
test "@rem"{
    try expect(@rem(5,2)==1);
    try expect(@rem(-5,2)==-1);
    const i:f32=0.4;
    try expect(@rem(6.4,2)==i);
    const j:f32=-0.4;
    try expect(@rem(-6.4,2)==j);
    const k=try @import("std").math.rem(i8,-6,4);
    try expect(k==-2);
}

const expect=@import("std").testing.expect;
test "@mod"{
    try expect(@mod(5,3)==2);
    try expect(@mod(-5,3)==1);
    const i:f32=-0.4;
    try expect(@mod(6.4,2)==i);
    const j:f32=1.6;
    try expect(@mod(-6.4,2)==j);
    const k=try @import("std").math.mod(i8,-6,4);
    try expect(k==2);
}

const expect=@import("std").testing.expect;
test "bit shift left"{
    var i:u3=2;
    var j:u8=4;
    try expect(j<<i==16);
    j=100;
    try expect(j<<2==144);
}

const expect=@import("std").testing.expect;
test "bit satu shift left"{
    var i:u3=2;
    var j:u8=4;
    try expect(j<<|i==16);
    j=100;
    try expect(j<<|2==255);
}

const expect=@import("std").testing.expect;
test "currect shlExact"{
    var i:i8=4;
    try expect(@shlExact(i,2)==16);
    i=-1;
    try expect(@shlExact(i,2)==-4);
}
test "unsigned shlExact" {
    var i:u8=100;
    try expect(@shlExact(i,2)==144);
}
test "signed shlExact" {
    var i:i8=0b0101_1000;
    try expect(@shlExact(i,2)==0b0110_00);
}

$ zig test --test-filter "currect shlExact" test_shlExact.zig
All 1 tests passed.
$ zig test --test-filter "unsigned shlExact" test_shlExact.zig
Test [1/1] test.unsigned shlExact... thread 10572 panic: left shift overflowed bits
$ zig test --test-filter "signed shlExact" test_shlExact.zig
Test [1/2] test.unsigned shlExact... thread 5776 panic: left shift overflowed bits

const print=@import("std").debug.print;
pub fn main() void{
    shli8(5,3);
    shli8(70,1);
    shli8(70,2);
    shli8(-70,1);
}
fn shli8(a:i8,b:u3) void{
    var r:i8=undefined;
    var ptr=&r;
    if(@shlWithOverflow(i8,a,b,ptr)){
        print("{}<<{} overflow, overflow result={}\n",.{a,b,ptr.*});
    }else{
        print("{}<<{} = {}\n",.{a,b,ptr.*});
    }    
}

$ zig run run_shlWithOverflow.zig
5<<3 = 40
70<<1 overflow, overflow result=-116
70<<2 overflow, overflow result=24
-70<<1 overflow, overflow result=116

test "bit shift right"{
    var m:u8=0b0101_1101;
    try expect(m>>2==0b0001_0111);
    m=0b1111_1100;
    try expect(m>>1==0b0111_1110);
    var n:i8=-2;
    try expect(n>>1==-1);
    n=0b0010_1010;
    try expect(n>>1==0b0001_0101);
}

const expect=@import("std").testing.expect;
test "currect shrExact" {
    var m:u8=0b1111_1100;
    try expect(@shrExact(m,1)==0b0111_1110);
}
test "shrExact UB"{
    var m:u8=0b0101_1101;
    try expect(@shrExact(m,2)==0b0001_0111);

}

$ zig test test --test-filter "currect shrExact" test_shrExact.zig
All 1 tests passed.
$ zig test test --test-filter "shrExact UB" test_shrExact.zig
Test [1/1] test.shrExact UB... thread 19740 panic: right shift overflowed bits

const expect=@import("std").testing.expect;
test "bit AND" {
    try expect(0b0011&0b0101==0b0001);
    const i:u16=0xF0F0;
    const j:u16=0x157A;
    try expect(i&j==0x1070);
}

const expect=@import("std").testing.expect;
test "bit OR" {
    try expect(0b0011|0b0101==0b0111);
    const i:u16=0xF0F0;
    const j:u16=0x157A;
    try expect(i|j==0xF5FA);
}

const expect=@import("std").testing.expect;
test "bit XOR" {
    try expect(0b0011^0b0101==0b0110);
    const i:u16=0xF0F0;
    const j:u16=0x157A;
    try expect(i^j==0xE58A);
}

const expect=@import("std").testing.expect;
test "bit NOT" {
    const k:u4=0b0101;
    try expect(~k==0b1010);
    const i:u8=0x0F;
    try expect(~i==0xF0);
    const j:u16=0x000F;
    try expect(~j==0xFFF0);
}

const expect=@import("std").testing.expect;
test "clz" {
    const i:u8=0b0001_0110;
    try expect(@clz(i)==3);
    const j:u16=i;
    try expect(@clz(j)==11);
    const k:u32=0;
    try expect(@clz(k)==32);
}

const expect=@import("std").testing.expect;
test "ctz" {
    const i:u8=0b0001_0100;
    try expect(@ctz(i)==2);
    const j:u16=i;
    try expect(@ctz(j)==2);
    const k:u32=0;
    try expect(@ctz(k)==32);
}

const expect=@import("std").testing.expect;
test "popCount" {
    const i:u8=0b0101_0110;
    try expect(@popCount(i)==4);
    const j:u16=i;
    try expect(@popCount(j)==4);
    const k:u8=0b1111_1111;
    try expect(@popCount(k)==8);
    const l:u32=0;
    try expect(@popCount(l)==0);
}

const expect=@import("std").testing.expect;
test "@byteSwap" {
    const i:u32=0x01020304;
    try expect(@byteSwap(i)==0x04030201);
    const j:u24=0x010203;
    try expect(@byteSwap(j)==0x030201);
}

const expect=@import("std").testing.expect;
test "@bitReverse" {
    const i:u8=0b1011_0110;
    try expect(@bitReverse(i)==0b0110_1101);
}

const expect=@import("std").testing.expect;
const std=@import("std");
const inf=std.math.inf(f32);
const nan=std.math.nan(f32);
const isNan=std.math.isNan;
test "@min" {
    try expect(@min(15,12)==12);
    try expect(@min(15.2,12)==12);
    try expect(@min(15,15)==15);
    try expect(@min(15.2,nan)==15.2);
    try expect(isNan(@min(nan,nan)));
}

const expect=@import("std").testing.expect;
const std=@import("std");
const inf=std.math.inf(f32);
const nan=std.math.nan(f32);
const isNan=std.math.isNan;
test "@max" {
    try expect(@max(15,12)==15);
    try expect(@max(15.2,12)==15.2);
    try expect(@max(15,15)==15);
    try expect(@max(15.2,nan)==15.2);
    try expect(isNan(@max(nan,nan)));
}

const expect=@import("std").testing.expect;
const std=@import("std");
const inf=std.math.inf(f32);
const negative_inf=-std.math.inf(f64);
const nan=std.math.nan(f128);
const isNan=std.math.isNan;
test "nan and inf" {
    var i:f64=1.0;
    var j:f64=0.0;
    i=i/j;
    try expect(i==inf);
    try expect(i>23.5);
    i=-i;
    try expect(i==-inf);
    try expect(i<23.5);
    var n=0/j;
    try expect(isNan(n));
}

const big=@as(f64,1<<40);
export fn foo_strict(x:f64) f64 {
    return x+big-big;
}
export fn foo_optimized(x: f64) f64 {
    @setFloatMode(.Optimized);
    return x+big-big;
}

$ zig build-obj foo.zig -O ReleaseFast

const print=@import("std").debug.print;
extern fn foo_strict(x:f64) f64;
extern fn foo_optimized(x:f64) f64;
pub fn main() void {
    const x=0.001;
    print("optimized={}\n", .{foo_optimized(x)});
    print("strict={}\n", .{foo_strict(x)});
}

$ zig build-exe float_mode.zig foo.obj
$ ./float_mode
optimized = 1.0e-03
strict = 9.765625e-04

pub const FloatMode = enum {
    Strict,
    Optimized,
};

const print=@import("std").debug.print;
var x:i32=1;
fn add5(x:*i32) bool{
    x.* +=5;
    return false;
}
pub fn main() void{
    print("{}",.{false and true}); // false
    _=false and add5(&x); // statA
    print("{}\n",.{x}); // 1
    const y=true and add5(&x); // statB
    print("{} {}\n",.{y,x}); // false 6
}

const expect=@import("std").testing.expect;
test "array"{
    var a=[_]u8{10,20};
    try expect(a.len==2);
    try expect(a[0]==10);
    a[1]+=5;
    try expect(a[1]==25);
}

const expect = @import("std").testing.expect;
// use compile-time code to initialize an array
var fancy_array = init: {
    var initial_value: [10]Point = undefined;
    for (initial_value) |*pt, i| {
        pt.* = Point{
            .x = @intCast(i32, i),
            .y = @intCast(i32, i) * 2,
        };
    }
    break :init initial_value;
};
const Point = struct {
    x: i32,
    y: i32,
};
test "compile-time array initialization" {
    try expect(fancy_array[4].x == 4);
    try expect(fancy_array[4].y == 8);
}

// call a function to initialize an array
var more_points = [_]Point{makePoint(3)} ** 10;
fn makePoint(x: i32) Point {
    return Point{
        .x = x,
        .y = x * 2,
    };
}
test "array initialization with function calls" {
    try expect(more_points[4].x == 3);
    try expect(more_points[4].y == 6);
    try expect(more_points.len == 10);
}

const expect = @import("std").testing.expect;
const mat4x4 = [4][4]f32{
    [_]f32{ 1.0, 0.0, 0.0, 0.0 },
    [_]f32{ 0.0, 1.0, 0.0, 1.0 },
    [_]f32{ 0.0, 0.0, 1.0, 0.0 },
    [_]f32{ 0.0, 0.0, 0.0, 1.0 },
};
test "multidimensional arrays" {
    try expect(mat4x4[1][1] == 1.0);
    for (mat4x4) |row, row_index| {
        for (row) |cell, column_index| {
            if (row_index == column_index) {
                try expect(cell == 1.0);
            }
        }
    }
}

const print = @import("std").debug.print;
pub fn main() !void {
    var m=[_]u8{4,3,2,1};
    var m1:[4]u8=undefined;
    for (m) |*item,i|{
        item.* +=3;
        m1[i]=m[i]*2;
    }
    print("{any}\n",.{m});
    print("{any}\n",.{m1});
    var sum:u16=0;
    for(m1) |item| {
        sum+=item;
    }
    print("{}\n",.{sum});
}

$ zig build-exe run_iter_arrays.zig
$ run_iter_arrays
{ 7, 6, 5, 4 }
{ 14, 12, 10, 8 }
44

const print=@import("std").debug.print;
pub fn main() void{
    const a=[_]u8{1,2,3,4};
    const b=[_]u8{10,20,30,40};
    var c:[4]u8=undefined;
    var i:usize=0;
    while(i<a.len):(i+=1){
        c[i]=a[i]+b[i];
    }
    print("{any}\n",.{c});
}

$ zig run run_array_while.zig
{ 11, 22, 33, 44 }

const expect=@import("std").testing.expect;
fn aeql(comptime T:type,a:T,b:T)bool{
    for(a) |v,i|{
        if(b[i]!=v){return false;}
    }
    return true;
}
test "array concat1" {
    const a1=[_]u32{1,2};
    const a2=[_]u32{3,4};
    const a=a1++a2;
    const b=[_]u32{1,2,3,4};
    try expect(aeql([4]u32,a,b));
}
test "array concat2" {
    const m="he"++"--"++"wo";
    const n="he--wo";
    try expect(aeql(*const [6:0]u8,m,n));
}

const expect=@import("std").testing.expect;
fn aeql(comptime T:type,a:T,b:T)bool{
    for(a) |v,i|{
        if(b[i]!=v){return false;}
    }
    return true;
}
test "array repeat1" {
    const a=[_]u32{1,2}**2;
    const b=[_]u32{1,2,1,2};
    try expect(aeql([4]u32,a,b));
}
test "array repeat2" {
    const a=[_]u32{5}**3;
    const b=[_]u32{5,5,5};
    try expect(aeql([3]u32,a,b));
}
test "array repeat3" {
    const m="abc"**2;
    const n="abcabc";
    try expect(aeql(*const [6:0]u8,m,n));
}

const expect=@import("std").testing.expect;
test "@Vector" {
    const a=@Vector(4,i32){1,2,3,4};
    try expect(a[2]==3);
    try expect(@sizeOf(@TypeOf(a))==16);
    try expect(@sizeOf(@TypeOf(a[0]))==4);
}

const expect=@import("std").testing.expect;
test "vector add" {
    var i=@Vector(4,i32){1,2,3,4};
    const j=@Vector(4,i32){10,20,30,40};
    var k=i+j;
    try expect(k[2]==33);
    try expect(@TypeOf(k)==@Vector(4,i32));
}

const std=@import("std");
const expect=std.testing.expect;
test "vector @splat" {
    const scalar:u32=5;
    const r=@splat(4,scalar);
    comptime try expect(@TypeOf(r)==@Vector(4,u32));
    try expect(std.mem.eql(u32,&@as([4]u32,r),&[_]u32{5,5,5,5}));
}

const expect=@import("std").testing.expect;
test "intger vector reduce" {
    var a=@Vector(4,u32){10,15,20,25};
    const r=@reduce(.Add, a);
    try expect(r==70);
}
test "bool vector reduce" {
    const a=@Vector(4,i32){1,-1,1,-1};
    const b=a > @splat(4,@as(i32,0));
    // b is {true,false,true,false}
    comptime try expect(@TypeOf(b)==@Vector(4,bool));
    const r= @reduce(.And, b);
    comptime try expect(@TypeOf(r)==bool);
    try expect(r==false);
}

const expect=@import("std").testing.expect;
const a=@Vector(4,u8){1,2,3,4};
const b=@Vector(4,u8){11,12,13,14};
const mask=@Vector(4,bool){true,false,true,false};
test "@select" {
    const c=@select(u8,mask,a,b);
    const c1=@Vector(4,u8){1,12,3,14};
    const rv=(c==c1);
    const r=@reduce(.And,rv);
    try expect(r);
}

for(i<mask.len):(i+=1){
    var index=mask[i];
    if(index>=0){
        c[i]=a[index];
    }else{
        c[i]=b[~@as(i32,index)];
    }
}

const std=@import("std");
const expect=std.testing.expect;
test "vector @shuffle" {
    const a=@Vector(7,u8){'o','l','h','e','r','z','w'};
    const b=@Vector(4,u8){'w','d','!','x'};
    const mask1=@Vector(5,i32){2,3,1,1,0};
    const res1:@Vector(5,u8)=@shuffle(u8,a,undefined,mask1);
    try expect(std.mem.eql(u8,&@as([5]u8,res1),"hello"));
    const mask2=@Vector(6,i32){-1,0,4,1,-2,-3};
    const res2: @Vector(6,u8)=@shuffle(u8,a,b,mask2);
    try expect(std.mem.eql(u8,&@as([6]u8,res2),"world!"));
}

const expect=@import("std").testing.expect;
test "assignment with array" {
    var a1=[_]i32{1,2,3,4};
    var vec:@Vector(4,i32)=a1;
    var a2:[4]i32=vec;
    try expect(a1[0]==a2[0]);
}
test "assignment with slice"{
    var a=[_]i32{1,2,3,4};
    var vec:@Vector(2,i32)=a[0..2].*;
    try expect(vec[1]==2);
    var s:[]const i32=&a;
    var off:usize=1;
    var vec1:@Vector(2,i32) = s[off..][0..2].*;
    try expect(vec1[0]==2);
    try expect(vec1[1]==3);

}

const expect=@import("std").testing.expect;
test "slice fat pointer"{
    var a=[_]i32{1,2,3,4};
    var le:usize=2;
    var s=a[0..le];
    try expect(s[1]==2);
    try expect(@TypeOf(s)==[]i32);
    try expect(@TypeOf(s.ptr)==[*]i32);
    try expect(s.len==2);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "comptime *[N]T" {
    const s=a[1..3];
    try expect(@TypeOf(s)==*[2]i32);
}
test "runtime []T" {
    var le:usize=3;
    const s=a[0..le];
    try expect(@TypeOf(s)==[]i32);
}

const print=@import("std").debug.print;
pub fn main() void{
    var a=[_]i32{1,2,3,4,5,6};
    var le:usize=4;
    var s=a[0..le];
    //s[5]+=10;
    s.len=100;
    s.ptr+=5;
    print("{} {}\n",.{s.ptr[0],s.ptr[9]});
}

$ zig run run_slice_bcheck.zig
6 2059402128

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
const expectEqual=std.testing.expectEqual;
const expect=std.testing.expect;
var al=std.testing.allocator;
test "ArrayList init" {
    var list=std.ArrayList(i32).init(al);
    defer list.deinit();
    try expect(list.capacity==0);
    try expect(list.items.len==0);
}
test "ArrayList initCapacity" {
    var list=try std.ArrayList(i32).initCapacity(al,200);
    defer list.deinit();
    try expect(list.capacity>=200);
    try expect(list.items.len==0);
}
test "ArrayList clone" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    try list.appendSlice("abc");
    var newl=try list.clone();
    defer newl.deinit();
    try expectEqual(list.allocator,newl.allocator);
    try expect(newl.capacity==list.capacity);
    try expectEqualSlices(u8,newl.items,"abc");
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
const expectEqual=std.testing.expectEqual;
const expect=std.testing.expect;
var al=std.testing.allocator;
test "ArrayList field" {
    var list=try std.ArrayList(u8).initCapacity(al,200);
    defer list.deinit();
    try expectEqual(al,list.allocator);
    try expect(list.capacity>=200);
    try expect(list.items.len==0);
    try list.appendSlice("abc");
    try expect(list.items.len==3);
    list.items[1]='B';
    try expectEqualSlices(u8,list.items,"aBc");    
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
const expect=std.testing.expect;
var al=std.testing.allocator;
test "ArrayList append" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    list.append(10) catch unreachable;
    list.append(20) catch unreachable;
    try list.append(30);
    try expect(list.items.len==3);
    try expectEqualSlices(u8,list.items,&[_]u8{10,20,30});
}
test "ArrayList appendSlice" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{10,20};
    try list.appendSlice(&a);
    try list.append(100);
    try list.appendSlice(&a);
    try expect(list.items.len==5);
    const r=[_]u8{10,20,100,10,20};
    try expectEqualSlices(u8,list.items,&r);
}
test "ArrayList appendUnalignedSlice" {
    var list=std.ArrayList(u32).init(al);
    defer list.deinit();
    try list.append(100);
    const a align(1)=[_]u32{1,2,3};
    try list.appendUnalignedSlice(&a);
    try expect(list.items.len==4);
    const r=[_]u32{100,1,2,3};
    try expectEqualSlices(u32,list.items,&r);
}
test "ArrayList appendNTimes" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    try list.append(10);
    try list.appendNTimes(50,4);
    try expect(list.items.len==5);
    const r=[_]u8{10,50,50,50,50};
    try expectEqualSlices(u8,list.items,&r);
}
test "ArrayList appendNTimesAssumeCapacity" {
    var list=try std.ArrayList(u8).initCapacity(al,100);
    defer list.deinit();
    try list.append(10);
    list.appendNTimesAssumeCapacity(50,4);
    try expect(list.items.len==5);
    const r=[_]u8{10,50,50,50,50};
    try expectEqualSlices(u8,list.items,&r);
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
var al=std.testing.allocator;
test "ArrayList insert" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{1,2,3};
    try list.appendSlice(&a);
    try list.insert(0,66);
    const r1=[_]u8{66,1,2,3};
    try expectEqualSlices(u8,list.items,&r1);
    try list.insert(2,77);
    const r2=[_]u8{66,1,77,2,3};
    try expectEqualSlices(u8,list.items,&r2);
    try list.insert(list.items.len,88);
    const r3=[_]u8{66,1,77,2,3,88};
    try expectEqualSlices(u8,list.items,&r3);
}
test "ArrayList insertSlice" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{1,2,3};
    list.appendSlice(&a) catch unreachable;
    const i=[_]u8{44,55};
    list.insertSlice(1,&i) catch unreachable;
    const r=[_]u8{1,44,55,2,3};
    try expectEqualSlices(u8,list.items,&r);
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
const expect=std.testing.expect;
var al=std.testing.allocator;
test "ArrayList orderRemove" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{11,22,33,44};
    try list.appendSlice(&a);
    const b=list.orderedRemove(1);
    try expect(b==22);
    const r=[_]u8{11,33,44};
    try expectEqualSlices(u8,list.items,&r);
}
test "ArrayList swapRemove" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{11,22,33,44,55};
    try list.appendSlice(&a);
    const b=list.swapRemove(1);
    try expect(b==22);
    const r=[_]u8{11,55,33,44};
    try expectEqualSlices(u8,list.items,&r);
}
test "ArrayList popOrNull" {
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{11,22};
    try list.appendSlice(&a);
    try expect(list.items.len==2);
    var b=list.popOrNull();
    try expect(b.?==22);
    try expect(list.items.len==1);
    b=list.popOrNull();
    try expect(b.?==11);
    try expect(list.items.len==0);
    b=list.popOrNull();
    try expect(b==null);
    try expect(list.items.len==0);
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
var al=std.testing.allocator;
test "ArrayList replaceRange" {
    const rep=[_]u8{55,66,77};
    var list=std.ArrayList(u8).init(al);
    defer list.deinit();
    const a=[_]u8{1,2,3,4,5};

    try list.appendSlice(&a);
    try list.replaceRange(2,0,&rep);
    const r1=[_]u8{1,2,55,66,77,3,4,5};
    try expectEqualSlices(u8,list.items,&r1);
    
    list.items.len=0;
    try list.appendSlice(&a);
    try list.replaceRange(2,2,&rep);
    const r2=[_]u8{1,2,55,66,77,5};
    try expectEqualSlices(u8,list.items,&r2);

    list.items.len=0;
    try list.appendSlice(&a);
    try list.replaceRange(2,3,&rep);
    const r3=[_]u8{1,2,55,66,77};
    try expectEqualSlices(u8,list.items,&r3);
    
    list.items.len=0;
    try list.appendSlice(&a);
    //try list.replaceRange(2,4,&rep);
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
const expect=std.testing.expect;
var al=std.testing.allocator;
test "ArrayList resize" {
    var list=try std.ArrayList(u8).initCapacity(al,10);
    defer list.deinit();
    try list.append(11);
    try expect(list.items.len==1);
    try expect(list.capacity>=10);
    const cap=list.capacity;

    try list.resize(8);
    try expect(list.items.len==8);
    try expect(list.capacity==cap);

    try list.resize(2000);
    try expect(list.items.len==2000);
    try expect(list.capacity>=2000);
    try expect(list.capacity>=cap);
}
test "ArrayList shrinkAndFree" {
    var list=try std.ArrayList(u8).initCapacity(al,10);
    defer list.deinit();
    try list.appendSlice(&[_]u8{1,2,3,4});
    try expect(list.items.len==4);
    try expect(list.capacity>=10);

    list.shrinkAndFree(2);
    try expect(list.items.len==2);
    try expect(list.capacity==2);
    try expectEqualSlices(u8,list.items,&[_]u8{1,2});
}

const std=@import("std");
const expectEqualSlices=std.testing.expectEqualSlices;
var al=std.testing.allocator;
test "ArrayList writer" {
    var buf=std.ArrayList(u8).init(al);
    defer buf.deinit();
    const writer=buf.writer();
    try expectEqualSlices(u8,buf.items,"");
    const i:i32=42;
    try writer.print("i={}\n",.{i});
    try expectEqualSlices(u8,buf.items,"i=42\n");
    try writer.writeAll(" all");
    try expectEqualSlices(u8,buf.items,"i=42\n all");
    try writer.writeAll(" ok!");
    try expectEqualSlices(u8,buf.items,"i=42\n all ok!");
}

const std=@import("std");
const expect=std.testing.expect;
var al=std.testing.allocator;
test "std.ArrayList(u0)" {
    var fa=std.testing.FailingAllocator.init(al, 0);
    const fall=fa.allocator();
    var list=std.ArrayList(u0).init(fall);
    defer list.deinit();
    try list.append(0);
    try list.append(0);
    try expect(list.items.len==2);
    var count:usize=0;
    for (list.items) |x| {
        try expect(x==0);
        count += 1;
    }
    try expect(count==2);
}

struct {
    fieldname1:T1,fieldname2:T2,fieldname3:T3,
    fn method1(var list) T {statements;}
    fn method2(var list) T {statements;}
    const varname1:T=initval1;
    var varname2:T=initval2;
}

const expect=@import("std").testing.expect;
const foo=struct{
    x:i32,y:i32,
    fn nop() void {}
    const z:i64=-5;
};
test "struct decl"{
    var f:foo=.{.x=3,.y=4};
    try expect(f.x==3);
    f.x=f.x+f.y;
    try expect(f.x==7);
    try expect(foo.z==-5);
    foo.nop();
}
test "struct undefined"{
    var f:foo=undefined;
    try expect(foo.z==-5);
    f.x=13;
    f.y=foo.z;
    try expect(f.y==-5);
    foo.nop();
}

const expect=@import("std").testing.expect;
const foo=struct{a:i32=15, b:i32};
test "default field value" {
    var f:foo=.{.b=10};
    try expect(f.a==f.b+5);
    var f1:foo=.{.a=5,.b=6};
    try expect(f1.a+f1.b==11);
}

const expect=@import("std").testing.expect;
test "fully anonymous struct"{
    try dump(.{.int = @as(u32, 1234),
        .float = @as(f64, 12.34),
        .b = true,
        .s = "hi",});
}
fn dump(args: anytype) !void {
    try expect(args.int == 1234);
    try expect(args.float == 12.34);
    try expect(args.b);
    try expect(args.s[0] == 'h');
    try expect(args.s[1] == 'i');
}

const expect=@import("std").testing.expect;
const foo=struct{
    x:i32,
    y:struct{m:f32,
        n:struct{i:bool},
    },
};
test "struct nesting"{
    var f:foo=.{.x=1,.y=.{.m=3.2,.n=.{.i=true}}};
    try expect(f.y.m==3.2);
    try expect(f.y.n.i);
}

const print=@import("std").debug.print;
const foo=struct{x:i32, y:struct{i:i8}};
fn list(comptime T: type) type {
    return struct{z:T};
}
pub fn main() void{
    const f=.{.x=1,.y=.{.i=@as(i8,2)}};
    print("variable: {s}\n",.{@typeName(foo)});
    print("sub struct:{s}\n",.{@typeName(@TypeOf(f.y))});
    print("anonymous:{s}\n", .{@typeName(struct{})});
    print("function:{s}\n", .{@typeName(list(i32))});
}

$ zig run run_struct_name.zig
variable: run_struct_name.foo
sub struct:struct{i: i8}
anonymous:run_struct_name.main__struct_2576
function:run_struct_name.list(i32)

const expect=@import("std").testing.expect;
const foo=struct{
    x:i32,
    const y:i64=5;
    fn nop() void {}
};
test "struct size"{
    var f:foo=.{.x=1};
    const s=@sizeOf(@TypeOf(f.x));
    try expect(@sizeOf(foo)==s);
}

const expect=@import("std").testing.expect;
const foo=struct{
    x:i32,y:i8,z:i64,
};
test "size not equal"{
    const f:foo=.{.x=1,.y=2,.z=3};
    const sx=@sizeOf(@TypeOf(f.x));
    const sy=@sizeOf(@TypeOf(f.y));
    const sz=@sizeOf(@TypeOf(f.z));
    try expect(sx==4);
    try expect(sy==1);
    try expect(sz==8);
    const s=@sizeOf(foo);
    try expect(s==16);
    try expect(s != sx+sy+sz);
}
const foo1=struct{x:i8,y:i8};
test "size equal"{
    const f:foo1=.{.x=11,.y=12};
    const sx=@sizeOf(@TypeOf(f.x));
    const sy=@sizeOf(@TypeOf(f.y));
    try expect(sx==1);
    try expect(sy==1);
    const s=@sizeOf(foo1);
    try expect(s==2);
    try expect(s == sx+sy);
}

const expect=@import("std").testing.expect;
const foo=struct{x:i32,
    fn init(x:i32) foo{
        return foo{.x=x};
    }
    fn plus(self:foo,p:i32) i32{
        return self.x+p;
    }
};
test "struct method self" {
    const f=foo.init(1);
    try expect(f.x==1);
    const i=foo.plus(f,15);
    const j=f.plus(15);
    try expect(i==j);
}

const expect=@import("std").testing.expect;
const empty=struct{};
pub const mathconst=struct {
    pub const pi=3.14;
    pub const e=2.72;
};
test "null struct" {
    const nothing:empty=.{};
    try expect(0==@sizeOf(@TypeOf(nothing)));
    try expect(@sizeOf(mathconst)==0);
    const c=2*mathconst.pi;
    try expect(c==6.28);
}

const expect=@import("std").testing.expect;
const point=struct{x:f32,y:f32};
fn setYBasedOnX(ptrx:*f32,v:f32) void {
    const p=@fieldParentPtr(point,"x",ptrx);
    p.y=v;
}
test "fieldParentPtr" {
    var p=point{.x=0.1234,.y=undefined};
    setYBasedOnX(&p.x,0.9);
    try expect(p.y==0.9);
}

const print=@import("std").debug.print;
const foo=packed struct{
    x:i8=1,
    y:i16=0x0202,
    z1:bool=true,
    z2:u3=0b000,
    z3:u4=0b1111,
    m:i16=0x0303,
};
pub fn main() void{
    const f:foo=.{};
    const ptr=@ptrCast(*[@sizeOf(foo)]u8,&f);
    const s=ptr.*;
    for(s) |e,i| {
        if(i==3){
            print("{b} ",.{e});
        }else{
            print("{x} ",.{e});
        }
    }
    print("\nstruct foo size is {}\n",.{@sizeOf(foo)});
}

$ zig run test_packed_struct.zig
1 2 2 11110001 3 3 0 0
struct foo size is 8

$ zig run test_packed_struct.zig
1 aa 2 10 1 0 f aa 3 3
struct foo size is 10

const native_endian = @import("builtin").target.cpu.arch.endian();
const expect = @import("std").testing.expect;
const Full = packed struct {number: u16};
const Divided = packed struct {half1: u8,
    quarter3: u4,quarter4: u4};
test "@bitCast between packed structs" {
    try doTheTest();
    comptime try doTheTest();
}
fn doTheTest() !void {
    try expect(@sizeOf(Full) == 2);
    try expect(@sizeOf(Divided) == 2);
    var full = Full{ .number = 0x1234 };
    var divided = @bitCast(Divided, full);
    switch (native_endian) {
        .Big => {
            try expect(divided.half1 == 0x12);
            try expect(divided.quarter3 == 0x3);
            try expect(divided.quarter4 == 0x4);
        },
        .Little => {
            try expect(divided.half1 == 0x34);
            try expect(divided.quarter3 == 0x2);
            try expect(divided.quarter4 == 0x1);
        },
    }
}

const expect=@import("std").testing.expect;
const BitField=packed struct{
    a: u3,b: u3,c: u2,d:u16};
var foo=BitField{.a=1,.b=2,.c=3,.d=7};
test "non-bit-aligned field"{
    var ptr=&foo;
    try expect(ptr.*.b==2);
    comptime{
        try expect(@bitOffsetOf(BitField,"a")==0);
        try expect(@bitOffsetOf(BitField,"b")==3);
        try expect(@bitOffsetOf(BitField,"c")==6);
        try expect(@bitOffsetOf(BitField,"d")==8);
        try expect(@offsetOf(BitField,"a")==0);
        try expect(@offsetOf(BitField,"b")==0);
        try expect(@offsetOf(BitField,"c")==0);
        try expect(@offsetOf(BitField,"d")==1);
    }
}

const expect=@import("std").testing.expect;
const BitField=packed struct{
    a: u3,b: u3,c: u2,d:u8};
var foo=BitField{.a=1,.b=2,.c=3,.d=5};
test "pointers of sub-byte-aligned fields share addresses" {
    try expect(@ptrToInt(&foo.a) == @ptrToInt(&foo.b));
    try expect(@ptrToInt(&foo.a) == @ptrToInt(&foo.c));
}
test "pointer to non-byte-aligned field" {
    const ptr = &foo.c;
    try expect(ptr.* == 3);
}

const expect=@import("std").testing.expect;
const state=enum{ok,notok,
    const p:i32=1;
    fn nop() void{}
};
test "enum"{
       try expect(@enumToInt(state.ok)==0);
       try expect(@enumToInt(state.notok)==1);
    try expect(u1==@TypeOf(@enumToInt(state.ok)));
    const s=state.ok;
    const s1:state=.ok;
    try expect(s==s1);
    try expect(state.p==1);
    state.nop();
}

const expect=@import("std").testing.expect;
const state=enum{ok,notok};
test "enum switch" {
    var i=state.ok;
    var r=switch(i){
        .ok=>true,
        .notok=>false,
    };
    try expect(r);
}

const expect=@import("std").testing.expect;
const foo=enum(u32){i1=100,
    i2,i3,
    i4=1100};
test "set enum ordinal value" {
    try expect(@enumToInt(foo.i1)==100);
    try expect(@enumToInt(foo.i2)==101);
    try expect(@enumToInt(foo.i3)==102);
    try expect(@enumToInt(foo.i4)==1100);
}

const expect=@import("std").testing.expect;
const foo=enum{ok,not_ok,
    fn isok(self:foo) bool{
        return self==foo.ok;}
};
test "Enum Methods"{
    const f=foo.ok;
    try expect(f.isok());
    try expect(foo.isok(f));
}

const expect=@import("std").testing.expect;
const foo=enum(u8){one,two,
    _,};
test "switch on non-exhaustive enum"{
    var f=foo.one;
    var r=switch(f){
        .one=>true,
        .two=>false,
        _=>false,
    };
    try expect(r);
    r=switch(f){
        .one=>true,
        else=>false,
    };
    try expect(r);
    f=@intToEnum(foo,12);
    r=switch(f){
        .one=>false,
        .two=>false,
        _=>true,
    };
    try expect(r);
}

const foo=enum{a,b,c};
export fn entry(f:foo) void {_=foo;}

zig build-obj exenum.zig
exenum.zig:4:17: error: parameter of type 'exenum.foo' not allowed in function with calling convention 'C'
export fn entry(f:foo) void {_=f;}
                ^``
exenum.zig:4:17: note: enum tag type 'u2' is not extern compatible
exenum.zig:4:17: note: only integers with power of two bits are extern compatible
exenum.zig:3:11: note: enum declared here
const foo=enum{a,b,c};
          ^``

const foo=enum(c_int){a,b,c};
export fn entry(f:foo) void {_=foo;}

zig build-obj exenum.zig

const expect=@import("std").testing.expect;
const expect=@import("std").testing.expect;
const foo=union{
    score:u8,notscore:void,
    fn pass(self:foo) bool{
        return self.score>=60;
    }
};
test "union" {
    var f1=foo{.score=70};
    try expect(foo.pass(f1));
    f1.score=55;
    try expect(!f1.pass());
}

const expect=@import("std").testing.expect;
const foo=union{x:i32,y:f64};
test "@unionInit" {
    const i=foo{.x=10};
    const j=@unionInit(foo,"x",10);
    try expect(i.x==j.x);
}

test "not active field" {
    const foo=union{i:i64,f:f64,b:bool,};
    var f1=foo{.i=1234};
    f1.i+=1;
    var f2=f1.f;
    _=f2;
}

$ zig test test_notactive_field.zig
Test [1/1] test.enum switch... thread 7432 panic: access of inactive union field

test "reassign active field" {
    const foo=union{i:i64,f:f64,b:bool,};
    var f1=foo{.i=1234};
    f1=foo{.f=12.5};
}

test "packed not active field" {
    const foo=packed union{i:i64,f:f64,b:bool,};
    var f1=foo{.i=1234};
    const f2=f1.f;
    _=f2;
}

const expect=@import("std").testing.expect;
const fooTag=enum{ok,notok};
const foo=union(fooTag){ok:u8,notok:void};
test "switch on tagged union" {
    const f=foo{.ok=5};
    switch (f){
        fooTag.ok => |v| try expect(v==5),
        fooTag.notok => unreachable,
    }
}
test "modify tagged union in switch" {
    var f=foo{.ok=6};
    switch (f){
        .ok => |*v| v.* += 1,
        .notok => unreachable,
    }
    try expect(f.ok==7);
}

const expect=@import("std").testing.expect;
const foo=union(enum){
    i:i32, b:bool,none,
    fn truthy(self:foo) bool{
        return switch(self){
            foo.i => |x| x!=0,
            foo.b => |x| x,
            foo.none => false,
        };
    }
};
test "union method"{
    var f1=foo{.i=1};
    var f2=foo{.b=false};
    try expect(f1.truthy());
    try expect(!f2.truthy());
}

const expect=@import("std").testing.expect;
const fooTag=enum{ok,notok};
const foo=union(fooTag){ok:u8,notok:void};
test "cast tag type"{
    const f=foo{.ok=2};
    try expect(@as(fooTag,f)==fooTag.ok);
}
test "coerce to enum" {
    const f1=foo{.ok=4};
    const f2=foo.notok;
    try expect(f1==.ok);
    try expect(f2==.notok);
}

test "optional add UB" {
    var i:?i32=1;
    i+=1;
}

test "optional add UB" {
    var i:?i32=1;
    var j:?i32=2;
    i+=j;
}

const expect=@import("std").testing.expect;
var opt:?i32=undefined;
test "assignment payload" {
    const i:i32=10;
    opt=i;
    try expect(opt==@as(?i32,10));
}
test "assignment null" {
    opt=null;
    try expect(opt==null);
}
test "assignment other optional" {
    const i:?i32=11;
    opt=i;
    try expect(opt==@as(?i32,11));
}

const expect=@import("std").testing.expect;
test "payload assignment" {
    var i:?i32=10;
    var j:i32=i;
    try expect(i==j);
}

test "get null payload" {
    var j:i32=null;
    _=j;
}

const expect=@import("std").testing.expect;
const i:?i32=10;
test "optional comparison" {
    var j:?i32=20;
    try expect(i!=j);
    j=10;
    try expect(i==j);
}
test "payload comparison" {
    var k:i32=30;
    try expect(i!=k);
    k=10;
    try expect(i==k);
}

const expect=@import("std").testing.expect;
test "null comparison" {
    var i:?i32=10;
    try expect(i!=null);
    i=null;
    try expect(i==null);
}

const expect=@import("std").testing.expect;
test "get payload" {
    var i:?i32=10;
    try expect(i.?==10);
    i.? +=5;
    try expect(i.?==15);
    const j=i.?;
    try expect(@TypeOf(j)==i32);
    try expect(j==15);
}

test "get null payload" {
    var i:?i32=null;
    _=i.?;
}

const expect=@import("std").testing.expect;
test "optional size" {
    comptime try expect(@sizeOf(?*i32) == @sizeOf(*i32));
}
test "null value" {
    var i:?i32=null;
    var j=@ptrCast(*i32,&i);
    try expect(j.*==0);
}
test "null not equal to 0" {
    var i:?i32=null;
    var j:i32=0;
    try expect(i!=j);
}

#include <stdlib.h>
struct foo *do(void){
    char *ptr=malloc(1234);
    if(!ptr) return null;
    // ...
}

extern fn malloc(size:size_t) ?*u8;
fn do() ?*foo{
    const ptr=malloc(1234) orelse return null;
    // ...
}

void do_foo(struct foo *f) {}
void do(struct foo *f){
    // do some stuff
    if(f) {
        do_foo(f);
    }
    // do some stuff
}

do_foo(f: *foo) void{_=f;}
do(f: ?*foo) void{
    // do some stuff
    if(f) |ptr| {
        do_foo(ptr);
    }
    // do some stuff
}

const expect=@import("std").testing.expect;
test "orelse payload" {
    var i:?i32=5;
    const j=i orelse 10;
    try expect(j==5);
    try expect(@TypeOf(j)==i32);
}
test "orelse null" {
    var i:?i32=null;
    const j=i orelse 10;
    try expect(j==10);
    try expect(@TypeOf(j)==i32);
}

const expect=@import("std").testing.expect;
const err1=error{erra0,erra1};
const err2=error{erra0};
test "error encode" {
    const x:err1=err1.erra0;
    const y=err2.erra0;
    try expect(x==y);
    const z=(error{erra0,erra1}).erra1;
    try expect(err1.erra0!=z);
    const w=error.erra0;
    const i=@errorToInt(w);
    const j=@errorToInt(w);
    try expect(i==j);
    try expect(@TypeOf(i)==u16);
}

const expect=@import("std").testing.expect;
const FileOpenError=error{
    AccessDenied,
    OutOfMemory,
    FileNotFound,
};
const AllocationError=error{
    OutOfMemory,
};
test "coerce subset to superset" {
    const err= foo(AllocationError.OutOfMemory);
    try expect(err==FileOpenError.OutOfMemory);
}
fn foo(err:AllocationError) FileOpenError{
    return err;
}

const superset=error{err1,err2,err3};
const subset=error{err2};
test "coerce superset to subset"{
    foo(superset.err2) catch {};
}
fn foo(e:superset) subset{
    return e;
}

error: expected type 'error{err2}', found 'error{err1,err2,err3}'
 return e;
        ^

const A = error{
    NotDir,
    PathNotFound,
};
const B = error{
    OutOfMemory,
    PathNotFound,
};
const C = A || B;
fn foo() C!void {
    return error.NotDir;
}
test "merge error sets" {
    if (foo()) {
        @panic("unexpected");
    } else |err| switch (err) {
        error.OutOfMemory => @panic("unexpected"),
        error.PathNotFound => @panic("unexpected"),
        error.NotDir => {},
    }
}

const expect=@import("std").testing.expect;
const foo=error{notbool,notint};
fn intobool(i:i32) foo!bool{
    if(i>0) {
        return true;
    }else if(i==0){
        return false;
    }else{
        return error.notbool;
    }
}
test "error union type"{
    var r=try intobool(10);
    try expect(r==true);
    var e1:foo=undefined;
    _=intobool(-10) catch |e| {e1=e;};
    try expect(e1==foo.notbool);
}

const expect=@import("std").testing.expect;
pub fn add_inferred(comptime T:type,a:T,b:T) !T{
    var r:T=undefined;
    return if(@addWithOverflow(T,a,b,&r)) error.Overflow else r;
}
pub fn add_explicit(comptime T:type,a:T,b:T) Err!T{
    var r:T=undefined;
    return if(@addWithOverflow(T,a,b,&r)) error.Overflow else r;
}
const Err=error{Overflow};
test "inferred error set" {
    if (add_inferred(u8,255,1)) |_| unreachable
        else |err| switch (err) {
            error.Overflow => {},
        }
    if (add_explicit(u8,255,1)) |_| unreachable
        else |err| switch (err) {
            error.Overflow => {},
        }
}

const expect=@import("std").testing.expect;
test "error union catch"{
    var a:anyerror!i32=error.notbool;
    const b1:i32=a catch 13;
    try expect(b1==13);
    const b4:i32=a catch |e| @errorToInt(e);
    try expect(b4>=0);
    a=1;
    const b2=a catch 13;
    try expect(b2==1);
    const b3=a catch unreachable;
    try expect(b3==1);
}

pub fn main() !void {
    try foo(12);
}
fn foo(x:i32) !void {
    if (x >= 5) {try bar();
    } else {try bang2();}
}
fn bar() !void {
    if (baz()) {try quux();
    } else |err| switch (err) {
        error.EONE => try hello(),}
}
fn baz() !void {
    try bang1();
}
fn quux() !void {
    try bang2();
}
fn hello() !void {
    try bang2();
}
fn bang1() !void {
    return error.EONE;
}
fn bang2() !void {
    return error.ETWO;
}

$ zig run run_err_trace.zig
error: ETWO
run_err_tracerun_err_trace.zig:26:5: 0x7ff6be80123e in bang1 (run_err_trace.exe.obj)
    return error.EONE;
    ^
run_err_tracerun_err_trace.zig:17:5: 0x7ff6be801345 in baz (run_err_trace.exe.obj)
    try bang1();
    ^
run_err_tracerun_err_trace.zig:29:5: 0x7ff6be80136e in bang2 (run_err_trace.exe.obj)
    return error.ETWO;
    ^
run_err_tracerun_err_trace.zig:23:5: 0x7ff6be8013e5 in run_err_trace (run_err_trace.exe.obj)
    try bang2();
    ^
run_err_tracerun_err_trace.zig:14:31: 0x7ff6be801484 in bar (run_err_trace.exe.obj)
        error.EONE => try run_err_trace(),}
                              ^
run_err_tracerun_err_trace.zig:8:18: 0x7ff6be8014e5 in foo (run_err_trace.exe.obj)
    if (x >= 5) {try bar();
                 ^
run_err_tracerun_err_trace.zig:5:5: 0x7ff6be80153a in main (run_err_trace.exe.obj)
    try foo(12);
    ^

main foo bar baz bang1
#bang1 return EONE
#in baz: try bang1(); return EONE
in bar: error.EONE => try hello()
#    bang2() return ETWO
#    in hello: try bang2() return ETWO
#in bar: try hello() return ETWO
#in foo: try bar() return ETWO
#in main: try foo() returen ETWO

pub fn main() void {
    foo(12);
}
fn foo(x:i32) void {
    if (x >= 5) {bar();
    } else {bang2();}
}
fn bar() void {
    if (baz()) {quux();
    } else{
        hello();}
}
fn baz() bool {
    return bang1();
}
fn quux() void {
    bang2();
}
fn hello() void {
    bang2();
}
fn bang1() bool {
    return false;
}
fn bang2() void {
    @panic("ETWO");
}

$zig run run_stack_trace.zig
thread 10116 panic: ETWO
D:/ziglearn/run_stack_trace.zig:29:5: 0x7ff78a2720c6 in bang2 (run_stack_trace.exe.obj)
    @panic("ETWO");
    ^
D:/ziglearn/run_stack_trace.zig:23:10: 0x7ff78a29e15e in run_stack_trace (run_stack_trace.exe.obj)
    bang2();
         ^
D:/ziglearn/run_stack_trace.zig:14:14: 0x7ff78a272090 in bar (run_stack_trace.exe.obj)
        run_stack_trace();}
             ^
D:/ziglearn/run_stack_trace.zig:8:21: 0x7ff78a2717e3 in foo (run_stack_trace.exe.obj)
    if (x >= 5) {bar();
                    ^
D:/ziglearn/run_stack_trace.zig:5:8: 0x7ff78a2712e3 in main (run_stack_trace.exe.obj)
    foo(12);
       ^
C:\zig\lib\std\start.zig:385:41: 0x7ff78a271297 in WinStartup (run_stack_trace.exe.obj)
    std.debug.maybeEnableSegfaultHandler();
                                        ^
???:?:?: 0x7ffa7b1f7033 in ??? (???)
???:?:?: 0x7ffa7c5a26a0 in ??? (???)

pub const StackTrace = struct {
    index: usize,
    instruction_addresses: [N]usize,
};

// marked as "no-inline" in LLVM IR
fn __zig_return_error(stack_trace: *StackTrace) void {
    stack_trace.instruction_addresses[stack_trace.index] = @returnAddress();
    stack_trace.index = (stack_trace.index + 1) % N;
}

const expect = @import("std").testing.expect;
test "null terminated array" {
    const array = [_:0]u8 {1, 2, 3, 4};
    try expect(@TypeOf(array) == [4:0]u8);
    try expect(array.len == 4);
    try expect(array[4] == 0);
}

const print=@import("std").debug.print;
pub fn main() void{
    const s1:[:0]const u8="hello";
    print("{} {}\n",.{s1.len,s1[5]}); // 5 0
    var array=[_]u8{3,2,0,13,12,0,23,22,0};
    var l:usize=5;
    const s2=array[0..l :0];
    print("{} {}\n",.{s2.len,@TypeOf(s2)}); // 5 [:0]u8
    print("{} {} {} {}\n",.{s2[2],s2[3],s2[4],s2[5]}); // 0 13 12 0
}

test "null term slice" {
    var a=[_]u8{3,2,1,0};
    var l:usize=2;
    const s=a[0..l :0];
    _=s;
}

const std=@import("std");
const fmt=std.fmt;
const print=std.debug.print;
pub fn main() !void{
    const h:[]const u8="hello";
    const w:[]const u8="世界";
    var all:[100]u8=undefined;
    const alls=all[0..];
    const hw=try fmt.bufPrint(alls,"{s} {s}",.{h,w});
    print("{s}\n",.{hw}); // Hello 世界
}

const std = @import("std");
// This is also available as `std.c.printf`.
pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
pub fn main() anyerror!void {
    const msg="hello,world\n";
    const msg1:[msg.len]u8=msg.*;
    _=printf(&msg);
    _=printf(&msg1);
}

zig build-exe run_sentineltermpointer.zig -lc
run_sentineltermpointer.zig:9:11: error: expected type '[*:0]const u8', found '*const [12]u8'
 _=printf(&msg1);
          ^``
run_sentineltermpointer.zig:9:11: note: a single pointer cannot cast into a many pointer

const Derp = opaque {};
const Wat = opaque {};
extern fn bar(d: *Derp) void;
fn foo(w: *Wat) callconv(.C) void {
    bar(w);
}
test "call foo" {
    foo(undefined);
}

$ zig test test_opauqe.zig
test_opauqe.zig:10:9: error: expected type '*test_opauqe.Derp', found '*test_opauqe.Wat'
    bar(w);
        ^
test_opauqe.zig:10:9: note: pointer type child 'test_opauqe.Wat' cannot cast into pointer type child 'test_opauqe.Derp'
test_opauqe.zig:6:13: note: opaque declared here
const Wat = opaque {};
            ^``` `
test_opauqe.zig:5:14: note: opaque declared here
const Derp = opaque {};
             ^``` `

fn foo(condition:bool, b:u32) void {
    const a=if (condition) b else return;
    _=a;
    @panic("do something with a");
}
test "noreturn" {
    foo(false,1);
}

const std = @import("std");
const builtin = @import("builtin");
const native_arch = builtin.cpu.arch;
const expect = std.testing.expect;
const WINAPI: std.builtin.CallingConvention = if (native_arch == .i386) .Stdcall else .C;
extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(WINAPI) noreturn;
test "foo" {
    const value = bar() catch ExitProcess(1);
    try expect(value == 1234);
}
fn bar() anyerror!u32 {
    return 1234;
}

$ zig test noreturn_from_exit.zig -target x86_64-windows --test-no-exec

void, int u0, int i0,
array [0]T, vector [0]T
array [N]T, vector [N]T, element is zero bit type
struct all fields is zero bit type
enum only 1 tag
union only 1 field

const expect=@import("std").testing.expect;
test "zero bit type" {
    const zero:void={};
    try expect(@sizeOf(@TypeOf(zero))==0);
    try expect(@sizeOf(u0)==0);
    try expect(@sizeOf(i0)==0);
    try expect(@sizeOf([0]i32)==0);
    try expect(@sizeOf(@Vector(0,i32))==0);
    const array=[_]void{zero,zero};
    try expect(@sizeOf(@TypeOf(array))==0);
    const struct0=struct{zero:void,zero1:void};
    try expect(@sizeOf(struct0)==0);
    const enum1=enum{one};
    try expect(@sizeOf(@TypeOf(enum1))==0);
    const union1=union{one:i32};
    try expect(@sizeOf(@TypeOf(union1))==0);
}

export fn entry() void {
    var x: void = {};
    var y: void = {};
    x = y;
}

0000000000000010 <entry>:
  10:    55                       push   %rbp
  11:    48 89 e5                 mov    %rsp,%rbp
  14:    5d                       pop    %rbp
  15:    c3                       retq   

const std=@import("std");
const expect=@import("std").testing.expect;
test "turn HashMap into a set with void" {
    var map = std.AutoHashMap(i32, void).init(std.testing.allocator);
    defer map.deinit();
    try map.put(1,{});
    try map.put(2,{});
    try expect(map.contains(2));
    try expect(!map.contains(3));
    _ = map.remove(2);
    try expect(!map.contains(2));
}

test "void is ignored" {
    returnsVoid();
}
fn returnsVoid() void {}

test "explicitly ignoring expression value" {
    _ = foo();
}
fn foo() i32 {
    return 1234;
}

const print=@import("std").debug.print;
pub fn main() void {
    const i:*i32=undefined;
    print("{}\n",.{i});
}

$ zig run run_pointer_decl.zig
i32@c98c3ff6d8
$ zig run run_pointer_decl.zig
i32@a393ffae8

const print=@import("std").debug.print;
pub fn main() void {
    const a=[_]i32{1,2,3,4};
    var i=&a[1];
    print("{}\n",.{@sizeOf(i32)});
    print("{}\n",.{i});
    i=&a[2];
    print("{}\n",.{i});
}

4
i32@7ff7c806529c
i32@7ff7c80652a0

const expect=@import("std").testing.expect;
test "dereference" {
    var i:i32=10;
    const j=&i;
    try expect(j.*==10);
    j.* += 20;
    try expect(i==30);
}
fn add5(a:*i32) void{
    a.*+=5;
}
test "pointer parameter" {
    var i:i32=20;
    add5(&i);
    try expect(i==25);
}

const expect=@import("std").testing.expect;
test "*T" {
    var i:i32=1;
    var j:*i32=&i;
    j.*+=3;
    try expect(i==4);
    var k:i32=5;
    j=&k;
    try expect(j.*==5);
}
test "*const T" {
    const i:i32=1;
    var j=&i;
    // j.* +=3;
    var k:i32=6;
    j=&k;
    try expect(j.*==6);
}
test "const *T" {
    var i:i32=1;
    const j=&i;
    j.*+=3;
    try expect(i==4);
    const k:i32=5;
    // j=&k;
    try expect(k==5);
}
test "const *const T" {
    const i:i32=1;
    const j=&i;
    // j.*+=3;
    const k:i32=1;
    // j=&k;
    try expect(j.*==k);
}

const expect=@import("std").testing.expect;
test "single item pointer" {
    var i:i32=1;
    var ptr=&i;
    try expect(ptr.*==1);
    // ptr+=1;
    // try expect(ptr[0]==1);
}

const expect=@import("std").testing.expect;
test "single item pointer array" {
    var i=[_]i32{1,2,3,4};
    const ptr=&i[2];
    try expect(@TypeOf(ptr)==*i32);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "assign array address" {
    const ptr:[*]i32=&a;
    try expect(ptr[1]==a[1]);
}
test "assign comptime slice *[N]T" {
    const ptr:[*]i32=a[1..3];
    try expect(ptr[1]==a[2]);
}
test "assign runtime slice []T" {
    var le:usize=3;
    const ptr:[*]i32=a[1..le].ptr;
    try expect(ptr[1]==a[2]);
}

const expect=@import("std").testing.expect;
test "single-item is assigned to many-item" {
    var i:i32=1;
    var ptr1:*[1]i32=&i;
    var ptr:[*]i32=ptr1;
    ptr[0]=2;
    try expect(i==2);
    ptr[3]=138705;
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "many-item pointer index" {
    const ptr:[*]i32=&a;
    try expect(ptr[1]==2);
    ptr[2]=33;
    try expect(a[2]==33);
}
test "many-item pointer arithmetic" {
    var ptr:[*]i32=&a;
    ptr+=2;
    ptr[0]=333;
    try expect(a[2]==333);
    ptr-=1;
    try expect(ptr[0]==2);
}

var a=[_]i32{1,2,3,4};
test "many-item pointer add" {
    var ptr:[*]i32=&a;
    var ptr1=ptr+2;
    const ptr2=ptr+ptr1;
    _=ptr2;
}

$ zig test test_many_item_add.zig
error: expected type 'usize', found '[*]i32'

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "many-item pointer add" {
    var ptr:[*]i32=&a;
    var s=ptr[1..3];
    try expect(@TypeOf(s)==*[2]i32);
    try expect(s.len=2);
    try expect(s[1]==3);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "assign array address" {
    var ptr=&a;
    try expect(@TypeOf(ptr)==*[4]i32);
}
test "assign slice" {
    var ptr=a[1..3];
    try expect(@TypeOf(ptr)==*[2]i32);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
var ptr=&a;
test "array ptr index and get len" {
    try expect(ptr[1]==2);
    try expect(ptr.len==4);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "array ptr dereference" {
    const a1=ptr.*;
    try expect(@TypeOf(a1)==[4]i32);
    try expect(a1[2]==3);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
var ptr=&a;
test "array ptr get slice" {
    const s=ptr[1..3];
    try expect(@TypeOf(s)==*[2]i32);
    try expect(s[0]==2);
}

const expect=@import("std").testing.expect;
test "optional pointer" {
    var i:i32=5;
    var j:?*i32=&i;
    const k:*i32=j orelse unreachable;
    const l:i32=k.*;
    try expect(l==i);
}

const expect=@import("std").testing.expect;
test "error union pointer" {
    var i:i32=5;
    var j:anyerror!*i32=&i;
    const k:*i32=try j;
    const m:i32=k.*;
    try expect(m==i);
}

const expect=@import("std").testing.expect;
test "error union optional pointer" {
    var i:i32=5;
    var j:anyerror!?*i32=&i;
    const k:?*i32=try j;
    const l:*i32=k orelse unreachable;
    const m:i32=l.*;
    try expect(m==i);
}

const expect=@import("std").testing.expect;
fn add5(a:i8) i8{return a+5;}
fn sub7(a:i8) i8{return a-7;}
const call_op=*const fn(a:i8) i8;
fn do(fn1:call_op,x:i8) i8{return fn1(x);}
test "function pointer"{
    try expect(do(add5,10)==15);
    var f:call_op=sub7;
    try expect(do(f,17)==10);
    f=add5;
    try expect(do(f,17)==22);
}

const expect=@import("std").testing.expect;
test "automatic dereference of pointer to substruct" {
    const foo1=struct{x:i32};
    const foo=struct{ptr:*foo1,ptr1:?*foo1,ptr2:*i32};
    var i:i32=10;
    var f1=foo1{.x=5};
    var f2=foo1{.x=10};
    var f=foo{.ptr=&f1,.ptr1=&f2,.ptr2=&i};
    try expect(f.ptr.*.x==f.ptr.x);
    try expect(f.ptr.x==5);
    try expect(f.ptr1.?.*.x==f.ptr1.?.x);
    try expect(@TypeOf(f.ptr2.*)==i32);
    try expect(@TypeOf(f.ptr2)==*i32);    
}

var zero:usize=0;
test "allowzero" {
    var ptr=@intToPtr(*allowzero i32, zero);
    _=ptr.*;
}
test "not allowzero" {
    var ptr=@intToPtr(*i32, zero);
    _=ptr.*;
}

$ zig test test_allowzero.zig
Test [2/2] test.not allowzero... thread 19532 panic: cast causes pointer to be null
D:/dev/zig/hello.zig:11:2: 0x7ff7a04e10e9 in test.not allowzero (test.exe.obj)
        var ptr=@intToPtr(*i32, zero);

const print=@import("std").debug.print;
pub fn main() void{
    const mmio_ptr = @intToPtr(*volatile u8, 0x12345678);
    print("{}\n",.{@TypeOf(mmio_ptr)}); // *volatile u8
}

test "type coercion - variable declaration" {
    var a:u8=1;
    var b:u16=a;  _=b;
}
fn foo(b: u16) void {
    _=b;
}
test "type coercion - function call" {
    var a:u8=1;
    foo(a);
}
test "type coercion - @as builtin" {
    var a:u8=1;
    var b=@as(u16,a);  _=b;
}

test "type coercion - @as builtin" {
    var a: u8 = 1;
    var b = @as(u16, a);
    _ = b;
}

fn foo(_:*const i32) void{}
test "const qualification"{
    var a:i32=1;
    var b:*i32=&a;
    foo(b);
}
const std=@import("std");
const expect=std.testing.expect;
const mem=std.mem;
test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
    const window_name = [1][*]const u8{"window name"};
    const x: [*]const ?[*]const u8 = &window_name;
    try expect(mem.eql(u8, std.mem.sliceTo(@ptrCast([*:0]const u8, x[0].?), 0), "window name"));
}

const builtin = @import("builtin");
const expect=@import("std").testing.expect;
test "integer widening" {
    var a: u8 = 250;
    var b: u16 = a;
    var c: u32 = b;
    var d: u64 = c;
    var e: u64 = d;
    var f: u128 = e;
    try expect(f == a);
}
test "implicit unsigned integer to signed integer" {
    var a: u8 = 250;
    var b: i16 = a;
    try expect(b == 250);
}
test "float widening" {
    // Note: there is an open issue preventing this from working on aarch64:
    // https://github.com/ziglang/zig/issues/3282
    if (builtin.target.cpu.arch == .aarch64) return error.SkipZigTest;
    var a: f16 = 12.34;
    var b: f32 = a;
    var c: f64 = b;
    var d: f128 = c;
    try expect(d == a);
}

test "implicit cast to comptime_int" {
    var f: f32 = 54.0 / 5;
    _ = f;
}

$ zig test test_ftoi.zig
test_ftoi.zig:2:23: error: ambiguous coercion of division operands 'comptime_float' and 'comptime_int'; non-zero remainder '4'
    var f: f32 = 54.0 / 5;
                 ``~^~~

const expect=@import("std").testing.expect;
test "coerce to optionals" {
    const x: ?i32 = 1234;
    const y: ?i32 = null;
    try expect(x.? == 1234);
    try expect(y == null);
}
test "coerce to optionals wrapped in error union" {
    const x: anyerror!?i32 = 1234;
    const y: anyerror!?i32 = null;
    try expect((try x).? == 1234);
    try expect((try y) == null);
}
test "coercion to error unions" {
    const x: anyerror!i32 = 1234;
    const y: anyerror!i32 = error.Failure;
    try expect((try x) == 1234);
    try std.testing.expectError(error.Failure, y);
}

const expect=@import("std").testing.expect;
test "coercing large integer type to smaller one when value is comptime known to fit" {
    const x: u64 = 255;
    const y: u8 = x;
    try expect(y == 255);
}

const expect=@import("std").testing.expect;
const E=enum{one,two,three};
const U=union(E){
    one:i32,two:f32,
    three};
test "coercion between unions and enums" {
    var u=U{.two=12.34};
    var e:E=u;
    try expect(e==E.two);
    const three=E.three;
    var otheru:U=three;
    try expect(otheru==E.three);
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
test "[]T to *[N]T" {
    var a=[4]i32{1,2,3,4};
    var s:[]i32=&(a[0..2].*);
    var a1:*[2]i32=s.ptr[0..2];
    try expect(@TypeOf(s)==[]i32);
    try expect(@TypeOf(a1)==*[2]i32);
}
test "[*]T to *[N]T" {
    const ptr:[*]i32=a[1..3];
    const a1:*[2]i32=ptr[0..2];
    try expect(a1[1]==a[2]);
}
test "*[N]T to []T" {
    var le:usize=3;
    const s:[]i32=a[1..le];
    try expect(s[1]==a[2]);
}
test "[*]T to []T" {
    const ptr:[*]i32=a[1..3];
    var le:usize=2;
    const s:[]i32=ptr[0..le];
    try expect(s[1]==a[2]);
}
test "*[N]T to [*]T" {
    const ptr:[*]i32=a[1..3];
    try expect(ptr[1]==a[2]);
}
test "[]T to [*]T" {
    var le:usize=3;
    const s:[]i32=a[1..le];
    const ptr:[*]i32=s.ptr;
    try expect(ptr[1]==a[2]);
}

const print=@import("std").debug.print;
pub fn main() void{
    const bytes align(@alignOf(u32)) = [_]u8{ 0x12, 0x13, 0x14, 0x15 };
    const u32_value = @import("std").mem.bytesAsSlice(u32, bytes[0..])[0];
    print("{x}",.{u32_value}); // 15141312
}

test "@intCast" {
    var a:u16=12;
    var b=@intCast(u8,a);
    _=b;
}
test "@intCast panic" {
    var a:u16=0xabcd;
    var b:u8=@intCast(u8,a);
    _=b;
}

zig test test_intcast.zig
Test [1/1] test.@intCast panic... thread 25940 panic: integer cast truncated bits

const expect=@import("std").testing.expect;
test "integer truncation" {
    var a: u16 = 0xabcd;
    var b: u8 = @truncate(u8, a);
    try expect(b == 0xcd);
}

const expect=@import("std").testing.expect;
test "@floatCast" {
    var i:f64=13.5;
    try expect(@floatCast(f32,i)==13.5);
    i=1.8e40;
    var j:f32=0;
    const inf:f32=1.0/j;
    try expect(@floatCast(f32,i)==inf);

}

const expect=@import("std").testing.expect;
test "@floatToInt" {
    var f:f32=5.4;
    try expect(@floatToInt(u8,f)==5);
}
test "@floatToInt UB" {
    var f:f32=100000.15;
    try expect(@floatToInt(u8,f)==100000);
}

const expect=@import("std").testing.expect;
test "@intToFloat" {
    var i:i32=15;
    var f=@intToFloat(f32,i);
    try expect(f==15);
    try expect(@TypeOf(f)==f32);
}

const expect=@import("std").testing.expect;
test "comptime @boolToInt" {
    const i:bool=true;
    const j=@boolToInt(i);
    try expect(j==1);
    try expect(@TypeOf(j)==comptime_int);
}
test "runtime @boolToInt" {
    var i:bool=false;
    var j=@boolToInt(i);
    try expect(j==0);
    try expect(@TypeOf(j)==u1);
}

const expect=@import("std").testing.expect;
const e1=enum{one};
const e=enum{one,two,three,four};
const u=union(enum){one:i32,two:i64};
test "enum to integer" {
    const i=@enumToInt(e.two);
    try expect(@TypeOf(i)==u2);
    try expect(i==1);
}
test "tagged union to integer" {
    const i=@enumToInt(u.one);
    try expect(@TypeOf(i)==u1);
    try expect(i==0);
}
test "one field" {
    const i=@enumToInt(e1.one);
    try expect(@TypeOf(i)==u0);
    try expect(i==0);
    // try expect(@TypeOf(i)==comptime_int);
}

const expect=@import("std").testing.expect;
const e=enum{one,two,three,four};
test "@intToEnum" {
    const i:i32=2;
    const j=@intToEnum(e,i);
    try expect(j==e.three);
}

const expect=@import("std").testing.expect;
const e=enum{one,two,three,four};
test "@intToEnum" {
    const i:i32=10;
    const j=@intToEnum(e,i);
    try expect(j==e.three);
}

const expect=@import("std").testing.expect;
const err1=error{one,two};
test "@errSetCast"{
    const e=error.two;
    const e1=@errSetCast(err1,e);
    try expect(@TypeOf(e1)==err1);
}

const err1=error{one,two};
test "@errSetCast UB"{
    var e=error.six;
    var e1=@errSetCast(err1,e);
    _=e1;
}

const print=@import("std").debug.print;
const err1=error{one,two};
pub fn main() !void{
    const i=@errorToInt(err1.two);
    print("{} {}\n",.{i,@TypeOf(i)}); // 2 u16
}

const print=@import("std").debug.print;
const err1=error{one,two};
pub fn main() !void{
    const i=@errorToInt(err1.two);
    const e=@intToError(i);
    print("{}\n",.{e==err1.two});
    var j:u16=0x7FFF;
    const e1=@intToError(j);    
    print("{}\n",.{e1});
}

$ zig run run_intToError.zig
true
thread 17936 panic: invalid error code

const expect=@import("std").testing.expect;
var i:i32=0x0A0A_0A0A;
var ptr=&i;
test "cast *i8"{
    var p=@ptrCast(*i8,ptr);
    try expect(p.*==0x0A);
}
test "cast [*]i16"{
    var p=@ptrCast([*]i16,ptr);
    try expect(p[0]==0x0A0A);
}
test "optional cast *u32"{
    var p:?*i32=ptr;
    var p1=@ptrCast(*u32,p);
    try expect(p1.*==0x0A0A_0A0A);        
}

test "null cast UB"{
    var p:?*i32=null;
    var p1=@ptrCast(*i16,p);
    _=p1;
}

const print=@import("std").debug.print;
pub fn main() !void{
    var i:i32=1;
    var ptr=&i;
    var j=@ptrToInt(ptr);
    print("{} {x}\n",.{@TypeOf(j),j});
}

const expect=@import("std").testing.expect;
test "@intToPtr" {
    const a=[_]i32{11,22,33,44};
    const ptr=&a[1];
    var addr=@ptrToInt(ptr);
    addr+=@sizeOf(i32);
    var ptr1=@intToPtr(*i32,addr);
    try expect(ptr1.*==a[2]);
}
test "cast allowzero" {
    const i:usize=0;
    const ptr=@intToPtr(*allowzero i32,i);
    _=ptr;
}
test "cast null" {
    const i:usize=0;
    const ptr=@intToPtr(?*i32,i);
    try expect(ptr==null);
}

test "cast 0" {
    const i:usize=0;
    const ptr=@intToPtr(*i32,i);
    _=ptr;
}

const print=@import("std").debug.print;
pub fn main() !void{
    const x:i8=-1;
    const y:u8=@bitCast(u8,x);
    print("{}\n",.{y});
    const a align(4)=[_]u8{0x12,0x13,0x14,0x15};
    const v=@bitCast(u32,a);
    print("{x}\n",.{v});
    var nan:f32=0.0;
    nan=0.0/nan;
    var i:u32=@bitCast(u32,nan);
    print("{x}\n",.{i});
}

255
15141312
ffc00000

const std=@import("std");
const expect=std.testing.expect;
const mem=std.mem;
test "peer resolve int widening"{
    var a:i8=12;
    var b:i16=34;
    var c=a+b;
    try expect(@TypeOf(c)==i16);
}
test "peer resolve arrays of different size to const slice"{
    try expect(mem.eql(u8,boolToStr(true),"true"));
    try expect(mem.eql(u8,boolToStr(false),"false"));
    comptime try expect(mem.eql(u8,boolToStr(true),"true"));
    comptime try expect(mem.eql(u8,boolToStr(false),"false"));
}
fn boolToStr(b: bool) []const u8{
    return if (b) "true" else "false";
}
test "peer resolve array and const slice"{
    try testPeerResolveArrayConstSlice(true);
    comptime try testPeerResolveArrayConstSlice(true);
}
fn testPeerResolveArrayConstSlice(b: bool) !void{
    const value1=if (b) "aoeu" else @as([]const u8,"zz");
    const value2=if (b) @as([]const u8,"zz") else "aoeu";
    try expect(mem.eql(u8,value1,"aoeu"));
    try expect(mem.eql(u8,value2,"zz"));
}
test "peer type resolution: ?T and T"{
    try expect(peerTypeTAndOptionalT(true,false).?==0);
    try expect(peerTypeTAndOptionalT(false,false).?==3);
    comptime{
        try expect(peerTypeTAndOptionalT(true,false).?==0);
        try expect(peerTypeTAndOptionalT(false,false).?==3);
    }
}
fn peerTypeTAndOptionalT(c: bool,b: bool) ?usize{
    if (c){
        return if (b) null else @as(usize,0);
    }
    return @as(usize,3);
}
test "peer type resolution: *[0]u8 and []const u8"{
    try expect(peerTypeEmptyArrayAndSlice(true,"hi").len==0);
    try expect(peerTypeEmptyArrayAndSlice(false,"hi").len==1);
    comptime{
        try expect(peerTypeEmptyArrayAndSlice(true,"hi").len==0);
        try expect(peerTypeEmptyArrayAndSlice(false,"hi").len==1);
    }
}
fn peerTypeEmptyArrayAndSlice(a: bool,slice: []const u8) []const u8{
    if (a){
        return &[_]u8{};
    }

    return slice[0..1];
}
test "peer type resolution: *[0]u8,[]const u8,and anyerror![]u8"{
   {
        var data="hi".*;
        const slice=data[0..];
        try expect((try peerTypeEmptyArrayAndSliceAndError(true,slice)).len==0);
        try expect((try peerTypeEmptyArrayAndSliceAndError(false,slice)).len==1);
    }
    comptime{
        var data="hi".*;
        const slice=data[0..];
        try expect((try peerTypeEmptyArrayAndSliceAndError(true,slice)).len==0);
        try expect((try peerTypeEmptyArrayAndSliceAndError(false,slice)).len==1);
    }
}
fn peerTypeEmptyArrayAndSliceAndError(a: bool,slice: []u8) anyerror![]u8{
    if (a){
        return &[_]u8{};
    }

    return slice[0..1];
}
test "peer type resolution: *const T and ?*T"{
    const a=@intToPtr(*const usize,0x123456780);
    const b=@intToPtr(?*usize,0x123456780);
    try expect(a==b);
    try expect(b==a);
}

const expect=@import("std").testing.expect;
const i=true;
test "switch expression" {
    const j:u8=switch(i){
        true => 1,
        false => 0,
    };
    try expect(j==1);
}
test "switch statement" {
    switch(i){
        true => {try expect(i);},
        false => {try expect(!i);},
    }
}

const expect=@import("std").testing.expect;
test "if experession"{
    const a:u32=5;
    const r=if(a!=0) 15 else 100;
    try expect(r==15);
}
test "if nest and block"{
    const a:u32=5; const b:u32=10;
    if(a!=b){
        try expect(true);
    }else if(b==10){
        try expect(true);
    }else{
        unreachable;
    }
}
test "else not required"{
    const a:u32=5;
    if(a==5){
        try expect(true);
    }
}

const expect=@import("std").testing.expect;
test "while basic"{
    var i:i32=0;
    while(i<10){i+=1;}
    try expect(i==10);
}

const expect=@import("std").testing.expect;
test "while break"{
    var i:i32=0;
    while(true){
        if(i==8) break;
        i+=1;}
    try expect(i==8);
}

const expect=@import("std").testing.expect;
test "while continue"{
    var i:i32=0;
    var sum:i32=0;
    while(i<5){
        if(i==2) continue;
        sum+=i;
    }
    try expect(i==8);
}

LOOP: if(cond==true) {
    block1;
    if(exp) {
        step;
        goto LOOP;
    }
    block2;
    step;
    goto LOOP;
}

const print=@import("std").debug.print;
pub fn main() void{
    var i:i32=0;
    while(i<5):(i+=1){
        if(i==2) continue;
        print("{}\n",.{i});
    }
    var j:i32=1;
    while(i+j<20):({i*=2;j*=3;}){
        print("{} {}\n",.{i,j});
    }
}

0
1
3
4
5 1
10 3

const expect=@import("std").testing.expect;
fn hasnum(num:i32)bool{
    var i:i32=0;
    const j=while(i<10):(i+=1){
        if(i==num) {break true;}
    }else false;
    return j;
}
test "while else" {
    try expect(hasnum(5));
    try expect(!hasnum(-5));
}

const expect=@import("std").testing.expect;
var a=[_]i32{1,2,3,4};
var i:i32=0;
test "for" {
    for(a) |v| {
        i+=v;
    }else{
        try expect(i==10);
    }
}

switch(condition) {
    a => expr,
    b,c => expr,
    d...e => expr,
    f => |v| expr,
    g => |*v| expr,
    else => expr,
}

const expect=@import("std").testing.expect;
fn sw(a:u64)u64{
    const zz:u64=103;
    return switch(a){
        1, 2, 3 => 0,
        5...100 => 1,
        101 => blk:{
            const c:u64=5;
            break :blk c*2+1;
        },
        zz => zz,
        blk:{
            const d:u32=5;
            const e:u32=100;
            break :blk d+e;
        } => 107,
        else => 9,
    };
}
test "switch simple" {
    try expect(sw(0)==9);
    try expect(sw(1)==0);
    try expect(sw(2)==0);
    try expect(sw(3)==0);
    try expect(sw(4)==9);
    try expect(sw(5)==1);
    try expect(sw(6)==1);
    try expect(sw(99)==1);
    try expect(sw(100)==1);
    try expect(sw(101)==11);
    try expect(sw(103)==103);
    try expect(sw(105)==107);
    try expect(sw(200)==9);
}

test "all case"{
    const b:bool=true;
    _=switch(b){
        true => 1,
        false => 0,};
}

test "not else"{
    const b:i8=1;
    _=switch(b){
        1...127 => true,
        0 => false,
    };
}

const expect=@import("std").testing.expect;
const uni=union(enum){a1:u32,a2:i64,a3:u32,b:bool};
const i=uni{.b=false};
test "condition is enum or tagged union" {
    switch(i) {
        .a1, .a3 => {},
        uni.a2 => {},
        .b => try expect(!i.b),
    }
}

const expect=@import("std").testing.expect;
test "capture v"{
    const a:i32=5;
    const r=switch(a) {
        0...4 => false,
        else => |v| if(v==5) true else false,
    };
    try expect(r);
}
test "capture index"{
    const a=[_]i32{11,1,33,44};
    for(a) |v,i| {
        if(v==i){
            try expect(i==1);
        }
    }
}
test "capture pointer"{
    var a=[_]i32{1,2,3,4};
    for(a) |*v|{
        v.*+=10;
    }
    const r=[_]i32{11,12,13,14};
    for(a) |v,i|{
        try expect(v==r[i]);
    }
}
test "capture _ "{
    const a=[_]i32{11,2,33,44};
    for(a) |_| {}
}
test "capture in switch" {
    var a=[_]i32{11,22,33,44};
    try expect(foo(&a,0)==11);
    try expect(foo(&a,1)==22);
    try expect(foo(&a,2)==43);
    try expect(a[2]==43);
}
fn foo(addr:*[4]i32,b:usize) i32{
    switch(addr[b]) {
        0...30 => |v| return v,
        31...50 => |*v| {
            v.*+=10;
            return v.*;
        },
        else => return 100,
    }
}

const expect=@import("std").testing.expect;
test "if" {
    const i:?u32=5;
    if(i) |v| {
        try expect(v==5);
    }else{
        try expect(false);
    }
    const j:?u32=null;
    if(j) |_|{
        unreachable;
    }else{
        try expect(j==null);
    }
}        
test "while" {
    var i:?u32=5;
    var num:i32=0;
    while(i) |*v| :(num+=1)  {
        if(v.*==2){i=null;}
        else{v.* -=1;}
    }else{
        try expect(i==null);
        try expect(num==4);
    }
}

const expect=@import("std").testing.expect;
test "if"{
    var a:anyerror!i32=1;
    if(a) |v|{
        try expect(v==1);
    }else |_|{
        unreachable;
    }
    if(a) |v|{
        try expect(v==1);
    }else |_| {}
    a=error.BadValue;
    if(a) |_|{} else |e|{
        try expect(e==error.BadValue);
    }
}
test "while" {
    var i:anyerror!u32=5;
    var num:i32=0;
    while(i) |*v| :(num+=1)  {
        if(v.*==2){i=error.BadValue;}
        else{v.* -=1;}
    }else |e|{
        try expect(e==error.BadValue);
        try expect(i==error.BadValue);
        try expect(num==4);
    }
}

const expect=@import("std").testing.expect;
test "if capture values type is optional"{
    const a:anyerror!?i32=1;
    if(a) |v|{
        try expect(v.?==1);
    }else |_| {}
}
test "if a pointer capture"{
    var a:anyerror!?i32=1;
    if(a) |*v|{
        v.*.?=2;
    }else |_| {}
    try expect((a catch @as(i32,0)).?==2);
}
test "if null"{
    const a:anyerror!?i32=null;
    if(a) |v|{
        try expect(v==null);
    }else |_| {}
}
test "if error"{
    const a:anyerror!?i32=error.BadValue;
    if(a) |_|{} else |e|{
        try expect(e==error.BadValue);
    }
}
test "while" {
    var i:anyerror!?u32=5;
    var num:i32=0;
    while(i) |*v| :(num+=1)  {
        if(v.*.?==2){i=error.BadValue;}
        else{v.*.? -=1;}
    }else |e|{
        try expect(e==error.BadValue);
        try expect(i==error.BadValue);
        try expect(num==4);
    }
}

const print=@import("std").debug.print;
pub fn main() void{
    var i:i32=0;
    outer1: while(true){
        while(i<5):(i+=1){
            print("loop.1 i={}\n",.{i});
            if(i==1) break :outer1;
        }
        print("break out,not output\n",.{});
    }
    i=0;
    outer2: while(i<3):(i+=1){
        var j:i32=i+1;
        while(j>=0):(j-=1){
            print("loop.2 i={},j={}\n",.{i,j});
            if(j==1) continue :outer2;
        }
        print("continue skip,not output\n",.{});
    }
}

loop.1 i=0
loop.1 i=1
loop.2 i=0,j=1
loop.2 i=1,j=2
loop.2 i=1,j=1
loop.2 i=2,j=3
loop.2 i=2,j=2
loop.2 i=2,j=1

const print=@import("std").debug.print;
pub fn main() void{
    outer1: for([_]i32{1,2,3}) |i|{
        for([_]i32{1,2,3}) |j|{
            print("break i={},j={}\n",.{i,j});
            break :outer1;
        }
    }
    outer2: for([_]i32{1,2,3}) |i|{
        for([_]i32{1,2}) |j|{
            print("continue i={},j={}\n",.{i,j});
            continue :outer2;
        }
    }
}

break i=1,j=1
continue i=1,j=1
continue i=2,j=1
continue i=3,j=1

const os_msg=switch(builtin.target.os.tag) {
    .linux => "we found a linux user",
    else => "not a linux user",
};
test "switch inside function" {
    switch (builtin.target.os.tag) {
        .fuchsia => {
            @compileError("fuchsia not supported");
        },
        else => {},
    }
}

const expect=@import("std").testing.expect;
const expectError = @import("std").testing.expectError;
fn isFieldOpt(comptime T:type, field_index:usize)!bool {
    const fields=@typeInfo(T).Struct.fields;
    return switch(field_index) {
        inline 0...fields.len - 1 => |idx| @typeInfo(fields[idx].field_type) == .Optional,
        else => return error.IndexOutOfBounds,
    };
}
const struct1=struct{a:u32,b:?u32};
fn isFieldOpt_roll(comptime T:type, field_index:usize)!bool {
    const fields=@typeInfo(T).Struct.fields;
    return switch(field_index) {
        0 => @typeInfo(fields[0].field_type) == .Optional,
        1 => @typeInfo(fields[1].field_type) == .Optional,
        else => return error.IndexOutOfBounds,
    };
}
fn isfiledopt_struct1(field_index:usize)!bool{
    return switch(field_index) {
        0 => false,
        1 => true,
        else => return error.IndexOutOfBounds,
    };
}
test "inline switch" {
    var index: usize = 0;
    try expect(!try isFieldOpt(struct1, index));
    index+=1;
    try expect(try isFieldOpt(struct1, index));
    index+=1;
    try expectError(error.IndexOutOfBounds, isFieldOpt(struct1, index));
}

const expect=@import("std").testing.expect;
test "inline while loop" {
    comptime var i=0;
    var sum: usize=0;
    inline while(i<3):(i+=1){
        const T=switch(i){
            0 => f32,
            1 => i8,
            2 => bool,
            else => unreachable,
        };
        sum += @typeName(T).len;
    }
    try expect(sum == 9);
}

const expect=@import("std").testing.expect;
test "inline while loop" {
    const nums=[_]i32{2,4,6};
    var sum: usize=0;
    inline for(nums) |v|{
        const T=switch(v){
            2 => f32,
            4 => i8,
            6 => bool,
            else => unreachable,
        };
        sum += @typeName(T).len;
    }
    try expect(sum == 9);
}

test "basic math" {
    const x = 1;
    const y = 2;
    if (x + y != 3) {
        unreachable;
    }
}

fn assert(ok: bool) void {
    if (!ok) unreachable;
}
test "this will fail" {
    assert(false);
}

const assert = @import("std").debug.assert;
test "type of unreachable" {
    comptime {
        assert(@TypeOf(unreachable) == noreturn);
    }
}

const expect=@import("std").testing.expect;
fn max(comptime T:type,a:T,b:T) T {
    return if (a>b) a else b;
}
fn BiggerInt(a:u64,b:u64) u64 {
    return max(u64,a,b);
}
test "comptime generic"{
    const a:u64=1; const b:u64=5;
    try expect(BiggerInt(a,b)==5);
    const c:f32=1.1; const d:f32=2.2;
    try expect(max(f32,c,d)==2.2);
}

fn max(comptime T:type,a:T,b:T) T {
    return if (a>b) a else b;
}
fn foo(cond:bool) void{
    const r=max(if(cond) f32 else i32, 1,2);
    _=r;
}
test "try to pass a runtime type"{
    var i:bool=true;
    foo(i);
}

$ zig test test_comknown.zig
test_comknown.zig:9:17: error: unable to resolve comptime value
 const r=max(if(cond) f32 else i32, 1,2);
                ^```
test_comknown.zig:9:17: note: condition in comptime branch must be comptime known

fn max(comptime T:type,a:T,b:T) T {
    return if (a>b) a else b;
}
test "try to compare bools"{
    _=max(bool,true,false);
}

$ zig test test_compbool.zig
test_compbool.zig:6:17: error: operator > not allowed for type 'bool'
    return if (a>b) a else b;
               ~^~

const expect=@import("std").testing.expect;
fn max(comptime T:type,a:T,b:T) T {
    if(T==bool){
        return a or b;
    }else{
    return if (a>b) a else b;
    }
}
test "try to compare bools"{
    try expect(max(bool,true,false)==true);
}

const expect=@import("std").testing.expect;
const CmdFn=struct{
    name: []const u8,
    func: fn(i32) i32,
};
const fnstr=[_]CmdFn{
    CmdFn{.name="one",.func=one},
    CmdFn{.name="two",.func=two},
    CmdFn{.name="three",.func=three},
};
fn one(v:i32) i32{return v+1;}
fn two(v:i32) i32{return v+2;}
fn three(v:i32) i32{return v+3;}
fn perform(comptime ch:u8,v:i32) i32{
    var r:i32=v;
    comptime var i=0;
    inline while (i<fnstr.len):(i+=1){
        if (fnstr[i].name[0]==ch) {
            r=fnstr[i].func(r);
        }
    }
    return r;
}

test "perform fn" {
    try expect(perform('o',2)==3);
    try expect(perform('t',2)==7);
    try expect(perform('w',2)==2);
}

extern fn exit() noreturn;
test "foo" {
    comptime {exit();
    }
}

const expect = @import("std").testing.expect;
fn fib(i:u32) u32{
    if (i<2) return i;
    return fib(i-1)+fib(i-2);
}
test "fibonacci" {
    try expect(fib(7)==13);
    comptime {
        try expect(fib(7)==13);
    }
}

const expect = @import("std").testing.expect;
fn fib(i:u32) u32{
    //if (i<2) return i;
    return fib(i-1)+fib(i-2);
}
test "fibonacci" {
    comptime {
        try expect(fib(7)==13);
    }
}

const expect = @import("std").testing.expect;
fn fib(i:i32) i32{
    //if (i<2) return i;
    return fib(i-1)+fib(i-2);
}
test "fibonacci" {
    comptime {
        try expect(fib(7)==13);
    }
}

$ zig test test_fib_err1.zig
test_fib_err1.zig:4:15: error: evaluation exceeded 1000 backwards branches
    return fib(i-1)+fib(i-2);
           ``` ^``
test_fib_err1.zig:4:15: note: use @setEvalBranchQuota() to raise the branch limit from 1000
test_fib_err1.zig:4:15: note: called from here (999 times)
test_fib_err1.zig:8:23: note: called from here
        try expect(fib(7)==13);
                   ``` ^~~