321 lines
7.7 KiB
Plaintext
321 lines
7.7 KiB
Plaintext
/* ===== 复杂类型嵌套综合测试 =====
|
||
* test20_complex — 结构体嵌套、切片、数组、方法、类型别名、枚举等
|
||
* 难度：5/5
|
||
*/
|
||
/* ---- 基础结构体 ---- */
|
||
type Point = struct {
|
||
var x: i32;
|
||
var y: i32;
|
||
}
|
||
|
||
/* ---- 嵌套结构体 ---- */
|
||
type Rect = struct {
|
||
var min: Point;
|
||
var max: Point;
|
||
}
|
||
|
||
/* ---- 含切片字段的结构体 (核心 bug 测试) ---- */
|
||
type Buffer = struct {
|
||
var data: []u8;
|
||
var len: usize;
|
||
}
|
||
|
||
/* ---- 含数组字段的结构体 ---- */
|
||
type MatrixRow = struct {
|
||
var items: [4]i32;
|
||
}
|
||
|
||
/* ---- 含指针字段的结构体 ---- */
|
||
type Node = struct {
|
||
var ptr: *i32;
|
||
var val: i32;
|
||
}
|
||
|
||
/* ---- 多层级嵌套：结构体里的结构体里的切片 ---- */
|
||
type Bundle = struct {
|
||
var name: *u8;
|
||
var buf: Buffer;
|
||
var row: MatrixRow;
|
||
var pt: Point;
|
||
}
|
||
|
||
/* ---- 枚举含数据 ---- */
|
||
type Status = enum {
|
||
Active: i32;
|
||
Inactive;
|
||
Pending: Point;
|
||
}
|
||
|
||
/* ---- 含方法的结构体 (方法定义在结构体内部) ---- */
|
||
type Counter = struct {
|
||
var val: i32;
|
||
|
||
fn inc(self: *Counter) i32 {
|
||
self.val = self.val + 1;
|
||
ret self.val;
|
||
}
|
||
|
||
fn add(self: *Counter, n: i32) i32 {
|
||
self.val = self.val + n;
|
||
ret self.val;
|
||
}
|
||
|
||
fn reset(self: *Counter) {
|
||
self.val = 0;
|
||
}
|
||
|
||
fn get(self: *Counter) i32 {
|
||
ret self.val;
|
||
}
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 1: 切片在结构体内部初始化 (修复的核心 bug)
|
||
* ============================================================ */
|
||
|
||
fn test_slice_in_struct() i32 {
|
||
var raw: [4]u8;
|
||
raw[0] = 65; raw[1] = 66; raw[2] = 67; raw[3] = 68;
|
||
|
||
/* Bug fix: { .ptr = ..., .len = ... } inside struct literal */
|
||
var b: Buffer = Buffer { .data = { .ptr = &raw[0], .len = 4 }, .len = 4 };
|
||
|
||
if b.len != 4 { ret 1; }
|
||
if b.data[0] != 65 { ret 2; }
|
||
if b.data[1] != 66 { ret 3; }
|
||
if b.data[3] != 68 { ret 4; }
|
||
|
||
/* Modify through slice — verify reflection */
|
||
b.data[0] = 90;
|
||
if raw[0] != 90 { ret 5; }
|
||
|
||
/* Initialize with shorter slice */
|
||
var b2: Buffer = Buffer { .data = { .ptr = &raw[2], .len = 2 }, .len = 2 };
|
||
if b2.len != 2 { ret 6; }
|
||
if b2.data[0] != 67 { ret 7; }
|
||
|
||
/* Slice field assignment via field access */
|
||
b2.data.ptr = &raw[0];
|
||
b2.data.len = 4;
|
||
if b2.data[0] != 90 { ret 8; }
|
||
if b2.data.len != 4 { ret 9; }
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 2: 结构体含数组字段
|
||
* ============================================================ */
|
||
|
||
fn test_struct_with_array() i32 {
|
||
var mr: MatrixRow = MatrixRow { .items = [4]i32{10, 20, 30, 40} };
|
||
|
||
if mr.items[0] != 10 { ret 1; }
|
||
if mr.items[1] != 20 { ret 2; }
|
||
if mr.items[2] != 30 { ret 3; }
|
||
if mr.items[3] != 40 { ret 4; }
|
||
|
||
/* 修改数组元素 */
|
||
mr.items[2] = 99;
|
||
if mr.items[2] != 99 { ret 5; }
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 3: 嵌套结构体初始化
|
||
* ============================================================ */
|
||
|
||
fn test_nested_struct() i32 {
|
||
var p: Point = Point { .x = 5, .y = 10 };
|
||
if p.x != 5 { ret 1; }
|
||
if p.y != 10 { ret 2; }
|
||
|
||
/* 嵌套结构体字面量 */
|
||
var r: Rect = Rect {
|
||
.min = Point { .x = 1, .y = 2 },
|
||
.max = Point { .x = 3, .y = 4 }
|
||
};
|
||
if r.min.x != 1 { ret 3; }
|
||
if r.min.y != 2 { ret 4; }
|
||
if r.max.x != 3 { ret 5; }
|
||
if r.max.y != 4 { ret 6; }
|
||
|
||
/* 修改嵌套字段 */
|
||
r.min.x = 100;
|
||
if r.min.x != 100 { ret 7; }
|
||
if r.min.y != 2 { ret 8; } /* unchanged */
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 4: 结构体成员方法 (实例方法调用)
|
||
* ============================================================ */
|
||
|
||
fn test_struct_method() i32 {
|
||
var c: Counter = Counter { .val = 0 };
|
||
|
||
/* 实例方法调用 c.inc(&c) */
|
||
var r1: i32 = c.inc(&c);
|
||
if r1 != 1 { ret 1; }
|
||
if c.val != 1 { ret 2; }
|
||
|
||
/* 带参数方法调用 c.add(&c, n) */
|
||
var r2: i32 = c.add(&c, 5);
|
||
if r2 != 6 { ret 3; }
|
||
if c.val != 6 { ret 4; }
|
||
|
||
/* 连续调用 (显式 self) */
|
||
c.reset(&c);
|
||
if c.val != 0 { ret 5; }
|
||
|
||
c.add(&c, 10);
|
||
c.inc(&c);
|
||
var r3: i32 = c.get(&c);
|
||
if r3 != 11 { ret 6; }
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 5: 结构体含指针字段
|
||
* ============================================================ */
|
||
|
||
fn test_ptr_in_struct() i32 {
|
||
var v: i32 = 42;
|
||
var n: Node = Node { .ptr = &v, .val = 99 };
|
||
|
||
if n.val != 99 { ret 1; }
|
||
if n.ptr[0] != 42 { ret 2; }
|
||
|
||
/* 通过指针修改 */
|
||
v = 100;
|
||
if n.ptr[0] != 100 { ret 3; }
|
||
|
||
/* 通过指针在结构体内修改 */
|
||
n.ptr[0] = 200;
|
||
if v != 200 { ret 4; }
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 6: 多层级复杂嵌套
|
||
* ============================================================ */
|
||
|
||
fn test_complex_nesting() i32 {
|
||
var str_data: [5]u8;
|
||
str_data[0] = 72; str_data[1] = 101;
|
||
str_data[2] = 108; str_data[3] = 108; str_data[4] = 111;
|
||
|
||
var bundle: Bundle = Bundle {
|
||
.name = &str_data[0],
|
||
.buf = Buffer { .data = { .ptr = &str_data[1], .len = 3 }, .len = 3 },
|
||
.row = MatrixRow { .items = [4]i32{1, 2, 3, 4} },
|
||
.pt = Point { .x = -5, .y = 15 }
|
||
};
|
||
|
||
/* Verify name */
|
||
if bundle.name[0] != 72 { ret 1; }
|
||
if bundle.name[4] != 111 { ret 2; }
|
||
|
||
/* Verify nested slice */
|
||
if bundle.buf.len != 3 { ret 3; }
|
||
if bundle.buf.data[0] != 101 { ret 4; }
|
||
if bundle.buf.data[2] != 108 { ret 5; }
|
||
|
||
/* Verify array field */
|
||
if bundle.row.items[0] != 1 { ret 6; }
|
||
if bundle.row.items[3] != 4 { ret 7; }
|
||
|
||
/* Verify nested struct field */
|
||
if bundle.pt.x != -5 { ret 8; }
|
||
if bundle.pt.y != 15 { ret 9; }
|
||
|
||
/* Modify nested slice */
|
||
bundle.buf.data[1] = 87; /* 'W' */
|
||
if str_data[2] != 87 { ret 10; }
|
||
|
||
/* Modify nested array */
|
||
bundle.row.items[2] = 33;
|
||
if bundle.row.items[2] != 33 { ret 11; }
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 测试 7: 枚举含结构体数据
|
||
* ============================================================ */
|
||
|
||
fn test_enum_complex() i32 {
|
||
var s: Status = Status { .Active = 42 };
|
||
|
||
/* Verify active variant */
|
||
match s {
|
||
.Active(val) => {
|
||
if val != 42 { ret 1; }
|
||
},
|
||
.Inactive => {
|
||
ret 2;
|
||
},
|
||
.Pending(px, py) => {
|
||
ret 3;
|
||
}
|
||
}
|
||
|
||
/* Test Inactive variant */
|
||
var s2: Status = Status { .Inactive };
|
||
var is_inactive: i32 = 0;
|
||
match s2 {
|
||
.Active(val) => {},
|
||
.Inactive => { is_inactive = 1; },
|
||
.Pending(px, py) => {}
|
||
}
|
||
if is_inactive != 1 { ret 4; }
|
||
|
||
/* Test Pending variant with struct data */
|
||
var s3: Status = Status { .Pending = Point { .x = 7, .y = 8 } };
|
||
match s3 {
|
||
.Active(val) => { ret 5; },
|
||
.Inactive => { ret 6; },
|
||
.Pending(px, py) => {
|
||
if px != 7 { ret 7; }
|
||
if py != 8 { ret 8; }
|
||
}
|
||
}
|
||
|
||
ret 0;
|
||
}
|
||
|
||
/* ============================================================
|
||
* 主函数
|
||
* ============================================================ */
|
||
|
||
fn main() i32 {
|
||
var r: i32;
|
||
|
||
r = test_slice_in_struct();
|
||
if r != 0 { ret r; }
|
||
|
||
r = test_struct_with_array();
|
||
if r != 0 { ret r + 100; }
|
||
|
||
r = test_nested_struct();
|
||
if r != 0 { ret r + 200; }
|
||
|
||
r = test_struct_method();
|
||
if r != 0 { ret r + 300; }
|
||
|
||
r = test_ptr_in_struct();
|
||
if r != 0 { ret r + 400; }
|
||
|
||
r = test_complex_nesting();
|
||
if r != 0 { ret r + 500; }
|
||
|
||
r = test_enum_complex();
|
||
if r != 0 { ret r + 600; }
|
||
|
||
ret 0;
|
||
}
|