aboutsummaryrefslogtreecommitdiff
path: root/test/behavior/array.zig
diff options
context:
space:
mode:
Diffstat (limited to 'test/behavior/array.zig')
-rw-r--r--test/behavior/array.zig489
1 files changed, 489 insertions, 0 deletions
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
new file mode 100644
index 0000000000..39ccc72960
--- /dev/null
+++ b/test/behavior/array.zig
@@ -0,0 +1,489 @@
+const std = @import("std");
+const testing = std.testing;
+const mem = std.mem;
+const expect = testing.expect;
+const expectEqual = testing.expectEqual;
+
+test "arrays" {
+ var array: [5]u32 = undefined;
+
+ var i: u32 = 0;
+ while (i < 5) {
+ array[i] = i + 1;
+ i = array[i];
+ }
+
+ i = 0;
+ var accumulator = @as(u32, 0);
+ while (i < 5) {
+ accumulator += array[i];
+
+ i += 1;
+ }
+
+ expect(accumulator == 15);
+ expect(getArrayLen(&array) == 5);
+}
+fn getArrayLen(a: []const u32) usize {
+ return a.len;
+}
+
+test "array with sentinels" {
+ const S = struct {
+ fn doTheTest(is_ct: bool) void {
+ if (is_ct) {
+ var zero_sized: [0:0xde]u8 = [_:0xde]u8{};
+ // Disabled at runtime because of
+ // https://github.com/ziglang/zig/issues/4372
+ expectEqual(@as(u8, 0xde), zero_sized[0]);
+ var reinterpreted = @ptrCast(*[1]u8, &zero_sized);
+ expectEqual(@as(u8, 0xde), reinterpreted[0]);
+ }
+ var arr: [3:0x55]u8 = undefined;
+ // Make sure the sentinel pointer is pointing after the last element
+ if (!is_ct) {
+ const sentinel_ptr = @ptrToInt(&arr[3]);
+ const last_elem_ptr = @ptrToInt(&arr[2]);
+ expectEqual(@as(usize, 1), sentinel_ptr - last_elem_ptr);
+ }
+ // Make sure the sentinel is writeable
+ arr[3] = 0x55;
+ }
+ };
+
+ S.doTheTest(false);
+ comptime S.doTheTest(true);
+}
+
+test "void arrays" {
+ var array: [4]void = undefined;
+ array[0] = void{};
+ array[1] = array[2];
+ expect(@sizeOf(@TypeOf(array)) == 0);
+ expect(array.len == 4);
+}
+
+test "array literal" {
+ const hex_mult = [_]u16{
+ 4096,
+ 256,
+ 16,
+ 1,
+ };
+
+ expect(hex_mult.len == 4);
+ expect(hex_mult[1] == 256);
+}
+
+test "array dot len const expr" {
+ expect(comptime x: {
+ break :x some_array.len == 4;
+ });
+}
+
+const ArrayDotLenConstExpr = struct {
+ y: [some_array.len]u8,
+};
+const some_array = [_]u8{
+ 0,
+ 1,
+ 2,
+ 3,
+};
+
+test "nested arrays" {
+ const array_of_strings = [_][]const u8{
+ "hello",
+ "this",
+ "is",
+ "my",
+ "thing",
+ };
+ for (array_of_strings) |s, i| {
+ if (i == 0) expect(mem.eql(u8, s, "hello"));
+ if (i == 1) expect(mem.eql(u8, s, "this"));
+ if (i == 2) expect(mem.eql(u8, s, "is"));
+ if (i == 3) expect(mem.eql(u8, s, "my"));
+ if (i == 4) expect(mem.eql(u8, s, "thing"));
+ }
+}
+
+var s_array: [8]Sub = undefined;
+const Sub = struct {
+ b: u8,
+};
+const Str = struct {
+ a: []Sub,
+};
+test "set global var array via slice embedded in struct" {
+ var s = Str{ .a = s_array[0..] };
+
+ s.a[0].b = 1;
+ s.a[1].b = 2;
+ s.a[2].b = 3;
+
+ expect(s_array[0].b == 1);
+ expect(s_array[1].b == 2);
+ expect(s_array[2].b == 3);
+}
+
+test "array literal with specified size" {
+ var array = [2]u8{
+ 1,
+ 2,
+ };
+ expect(array[0] == 1);
+ expect(array[1] == 2);
+}
+
+test "array len field" {
+ var arr = [4]u8{ 0, 0, 0, 0 };
+ var ptr = &arr;
+ expect(arr.len == 4);
+ comptime expect(arr.len == 4);
+ expect(ptr.len == 4);
+ comptime expect(ptr.len == 4);
+}
+
+test "single-item pointer to array indexing and slicing" {
+ testSingleItemPtrArrayIndexSlice();
+ comptime testSingleItemPtrArrayIndexSlice();
+}
+
+fn testSingleItemPtrArrayIndexSlice() void {
+ {
+ var array: [4]u8 = "aaaa".*;
+ doSomeMangling(&array);
+ expect(mem.eql(u8, "azya", &array));
+ }
+ {
+ var array = "aaaa".*;
+ doSomeMangling(&array);
+ expect(mem.eql(u8, "azya", &array));
+ }
+}
+
+fn doSomeMangling(array: *[4]u8) void {
+ array[1] = 'z';
+ array[2..3][0] = 'y';
+}
+
+test "implicit cast single-item pointer" {
+ testImplicitCastSingleItemPtr();
+ comptime testImplicitCastSingleItemPtr();
+}
+
+fn testImplicitCastSingleItemPtr() void {
+ var byte: u8 = 100;
+ const slice = @as(*[1]u8, &byte)[0..];
+ slice[0] += 1;
+ expect(byte == 101);
+}
+
+fn testArrayByValAtComptime(b: [2]u8) u8 {
+ return b[0];
+}
+
+test "comptime evalutating function that takes array by value" {
+ const arr = [_]u8{ 0, 1 };
+ _ = comptime testArrayByValAtComptime(arr);
+ _ = comptime testArrayByValAtComptime(arr);
+}
+
+test "implicit comptime in array type size" {
+ var arr: [plusOne(10)]bool = undefined;
+ expect(arr.len == 11);
+}
+
+fn plusOne(x: u32) u32 {
+ return x + 1;
+}
+
+test "runtime initialize array elem and then implicit cast to slice" {
+ var two: i32 = 2;
+ const x: []const i32 = &[_]i32{two};
+ expect(x[0] == 2);
+}
+
+test "array literal as argument to function" {
+ const S = struct {
+ fn entry(two: i32) void {
+ foo(&[_]i32{
+ 1,
+ 2,
+ 3,
+ });
+ foo(&[_]i32{
+ 1,
+ two,
+ 3,
+ });
+ foo2(true, &[_]i32{
+ 1,
+ 2,
+ 3,
+ });
+ foo2(true, &[_]i32{
+ 1,
+ two,
+ 3,
+ });
+ }
+ fn foo(x: []const i32) void {
+ expect(x[0] == 1);
+ expect(x[1] == 2);
+ expect(x[2] == 3);
+ }
+ fn foo2(trash: bool, x: []const i32) void {
+ expect(trash);
+ expect(x[0] == 1);
+ expect(x[1] == 2);
+ expect(x[2] == 3);
+ }
+ };
+ S.entry(2);
+ comptime S.entry(2);
+}
+
+test "double nested array to const slice cast in array literal" {
+ const S = struct {
+ fn entry(two: i32) void {
+ const cases = [_][]const []const i32{
+ &[_][]const i32{&[_]i32{1}},
+ &[_][]const i32{&[_]i32{ 2, 3 }},
+ &[_][]const i32{
+ &[_]i32{4},
+ &[_]i32{ 5, 6, 7 },
+ },
+ };
+ check(&cases);
+
+ const cases2 = [_][]const i32{
+ &[_]i32{1},
+ &[_]i32{ two, 3 },
+ };
+ expect(cases2.len == 2);
+ expect(cases2[0].len == 1);
+ expect(cases2[0][0] == 1);
+ expect(cases2[1].len == 2);
+ expect(cases2[1][0] == 2);
+ expect(cases2[1][1] == 3);
+
+ const cases3 = [_][]const []const i32{
+ &[_][]const i32{&[_]i32{1}},
+ &[_][]const i32{&[_]i32{ two, 3 }},
+ &[_][]const i32{
+ &[_]i32{4},
+ &[_]i32{ 5, 6, 7 },
+ },
+ };
+ check(&cases3);
+ }
+
+ fn check(cases: []const []const []const i32) void {
+ expect(cases.len == 3);
+ expect(cases[0].len == 1);
+ expect(cases[0][0].len == 1);
+ expect(cases[0][0][0] == 1);
+ expect(cases[1].len == 1);
+ expect(cases[1][0].len == 2);
+ expect(cases[1][0][0] == 2);
+ expect(cases[1][0][1] == 3);
+ expect(cases[2].len == 2);
+ expect(cases[2][0].len == 1);
+ expect(cases[2][0][0] == 4);
+ expect(cases[2][1].len == 3);
+ expect(cases[2][1][0] == 5);
+ expect(cases[2][1][1] == 6);
+ expect(cases[2][1][2] == 7);
+ }
+ };
+ S.entry(2);
+ comptime S.entry(2);
+}
+
+test "read/write through global variable array of struct fields initialized via array mult" {
+ const S = struct {
+ fn doTheTest() void {
+ expect(storage[0].term == 1);
+ storage[0] = MyStruct{ .term = 123 };
+ expect(storage[0].term == 123);
+ }
+
+ pub const MyStruct = struct {
+ term: usize,
+ };
+
+ var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1;
+ };
+ S.doTheTest();
+}
+
+test "implicit cast zero sized array ptr to slice" {
+ {
+ var b = "".*;
+ const c: []const u8 = &b;
+ expect(c.len == 0);
+ }
+ {
+ var b: [0]u8 = "".*;
+ const c: []const u8 = &b;
+ expect(c.len == 0);
+ }
+}
+
+test "anonymous list literal syntax" {
+ const S = struct {
+ fn doTheTest() void {
+ var array: [4]u8 = .{ 1, 2, 3, 4 };
+ expect(array[0] == 1);
+ expect(array[1] == 2);
+ expect(array[2] == 3);
+ expect(array[3] == 4);
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "anonymous literal in array" {
+ const S = struct {
+ const Foo = struct {
+ a: usize = 2,
+ b: usize = 4,
+ };
+ fn doTheTest() void {
+ var array: [2]Foo = .{
+ .{ .a = 3 },
+ .{ .b = 3 },
+ };
+ expect(array[0].a == 3);
+ expect(array[0].b == 4);
+ expect(array[1].a == 2);
+ expect(array[1].b == 3);
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "access the null element of a null terminated array" {
+ const S = struct {
+ fn doTheTest() void {
+ var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
+ expect(array[4] == 0);
+ var len: usize = 4;
+ expect(array[len] == 0);
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "type deduction for array subscript expression" {
+ const S = struct {
+ fn doTheTest() void {
+ var array = [_]u8{ 0x55, 0xAA };
+ var v0 = true;
+ expectEqual(@as(u8, 0xAA), array[if (v0) 1 else 0]);
+ var v1 = false;
+ expectEqual(@as(u8, 0x55), array[if (v1) 1 else 0]);
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "sentinel element count towards the ABI size calculation" {
+ const S = struct {
+ fn doTheTest() void {
+ const T = packed struct {
+ fill_pre: u8 = 0x55,
+ data: [0:0]u8 = undefined,
+ fill_post: u8 = 0xAA,
+ };
+ var x = T{};
+ var as_slice = mem.asBytes(&x);
+ expectEqual(@as(usize, 3), as_slice.len);
+ expectEqual(@as(u8, 0x55), as_slice[0]);
+ expectEqual(@as(u8, 0xAA), as_slice[2]);
+ }
+ };
+
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "zero-sized array with recursive type definition" {
+ const U = struct {
+ fn foo(comptime T: type, comptime n: usize) type {
+ return struct {
+ s: [n]T,
+ x: usize = n,
+ };
+ }
+ };
+
+ const S = struct {
+ list: U.foo(@This(), 0),
+ };
+
+ var t: S = .{ .list = .{ .s = undefined } };
+ expectEqual(@as(usize, 0), t.list.x);
+}
+
+test "type coercion of anon struct literal to array" {
+ const S = struct {
+ const U = union{
+ a: u32,
+ b: bool,
+ c: []const u8,
+ };
+
+ fn doTheTest() void {
+ var x1: u8 = 42;
+ const t1 = .{ x1, 56, 54 };
+ var arr1: [3]u8 = t1;
+ expect(arr1[0] == 42);
+ expect(arr1[1] == 56);
+ expect(arr1[2] == 54);
+
+ var x2: U = .{ .a = 42 };
+ const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
+ var arr2: [3]U = t2;
+ expect(arr2[0].a == 42);
+ expect(arr2[1].b == true);
+ expect(mem.eql(u8, arr2[2].c, "hello"));
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
+
+test "type coercion of pointer to anon struct literal to pointer to array" {
+ const S = struct {
+ const U = union{
+ a: u32,
+ b: bool,
+ c: []const u8,
+ };
+
+ fn doTheTest() void {
+ var x1: u8 = 42;
+ const t1 = &.{ x1, 56, 54 };
+ var arr1: *const[3]u8 = t1;
+ expect(arr1[0] == 42);
+ expect(arr1[1] == 56);
+ expect(arr1[2] == 54);
+
+ var x2: U = .{ .a = 42 };
+ const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
+ var arr2: *const [3]U = t2;
+ expect(arr2[0].a == 42);
+ expect(arr2[1].b == true);
+ expect(mem.eql(u8, arr2[2].c, "hello"));
+ }
+ };
+ S.doTheTest();
+ comptime S.doTheTest();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 04:49:27 +0000