radiance · Radiance self-hosting compiler

test/tests/bool.comparison.slice.rad 4.1 KiB raw

//! returns: 0
fn memEq(a: *[u8], b: *[u8]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

fn sliceU8(input: *[u8]) -> *[u8] {
    return input;
}

fn sliceI32(input: *[i32]) -> *[i32] {
    return input;
}

fn sliceEqualU32(a: *[u32], b: *[u32]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

fn sliceEqualI32(a: *[i32], b: *[i32]) -> bool {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

fn sliceEqual1() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[..];
    let s2: *[u32] = &a1[..];

    return s1 == s2 and sliceEqualU32(s1, s2);
}

fn sliceEqual2() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[1..];
    let s2: *[u32] = &a1[1..];

    return s1 == s2 and sliceEqualU32(s1, s2);
}

fn sliceEqual3() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[..1];
    let s2: *[u32] = &a1[..1];

    return s1 == s2 and sliceEqualU32(s1, s2);
}

fn sliceEqual4() -> bool {
    let a1: [u32; 3] = [9, 42, 3];

    let s1: *[u32] = &a1[2..];
    let s2: *[u32] = &a1[2..];

    return s1 == s2 and sliceEqualU32(s1, s2);
}

fn sliceNotEqualSameArray1() -> bool {
    let a1: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..2];
    let s2: *[u32] = &a1[1..3];

    return s1 <> s2 and not sliceEqualU32(s1, s2);
}

fn sliceNotEqualSameArray2() -> bool {
    let a1: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..2];
    let s2: *[u32] = &a1[..3];

    return s1 <> s2 and not sliceEqualU32(s1, s2);
}

fn sliceEqualDifferentArray() -> bool {
    let a1: [u32; 3] = [42, 8, 3];
    let a2: [u32; 3] = [42, 8, 3];

    let s1: *[u32] = &a1[..];
    let s2: *[u32] = &a2[..];

    return sliceEqualU32(s1, s2) and s1 <> s2;
}

fn sliceEqualString1() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = "ABC";

    return memEq(s1, s2);
}

fn sliceEqualString2() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = "DEF";

    return not memEq(s1, s2);
}

fn sliceEqualString3() -> bool {
    let a1: [u8; 3] = ['A', 'B', 'C'];
    let s1: *[u8] = &a1[..];
    let s2: *[u8] = "ABC";

    return memEq(s1, s2)
       and memEq(s1, "ABC")
       and memEq(&a1[..], "ABC");
}

fn sliceEqualString4() -> bool {
    let s1: *[u8] = "ABC";
    let s2: *[u8] = &['A', 'B', 'C'];

    return memEq(s1, s2);
}

fn sliceEqualString5() -> bool {
    let s1: *[u8] = "ABC";

    // Sub-slicing a slice currently trips a separate compiler bug.
    // Keep this check focused on slice equality behavior itself.
    return memEq(s1, "ABC");
}

fn sliceNotEqualU8() -> bool {
    let a: [u8; 3] = [1, 2, 3];
    let b: [u8; 3] = [1, 2, 4];
    let s: *[u8] = &[1, 2, 3];

    return not memEq(s, &[1, 2, 4])
       and not memEq(s, &[1, 0, 3])
       and not memEq("ABC", "ABCD")
       and not memEq("ABC", "ABD")
       and not memEq(&a[..], &a[1..])
       and not memEq(&a[..], &b[..])
       and not memEq(&a[..], &[1, 3, 3]);
}

fn sliceNotEqualU16() -> bool {
    let a: [u16; 3] = [1, 2, 3];
    let b: [u16; 3] = [1, 2, 4];
    let s: *[u16] = &[1, 2, 3];

    return s <> &[1, 2, 4]
       and s <> &[1, 0, 3]
       and &a[..] <> &a[1..]
       and &a[..] <> &b[..]
       and &a[..] <> &[1, 3, 3];
}

fn sliceReturnEqual() -> bool {
    return memEq(sliceU8("ABC"), "ABC")
       and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);
}

@default fn main() -> i32 {
    assert sliceEqual1();
    assert sliceEqual2();
    assert sliceEqual3();
    assert sliceEqual4();
    assert sliceEqualString1();
    assert sliceEqualString2();
    assert sliceEqualString3();
    assert sliceEqualString4();
    assert sliceEqualString5();
    assert sliceNotEqualSameArray1();
    assert sliceNotEqualSameArray2();
    assert sliceEqualDifferentArray();
    assert sliceNotEqualU8();
    assert sliceNotEqualU16();
    assert sliceReturnEqual();

    return 0;
}

1	//! returns: 0
2	fn memEq(a: [u8], b: [u8]) -> bool {
3	if a.len <> b.len {
4	return false;
5	}
6	for i in 0..a.len {
7	if a[i] <> b[i] {
8	return false;
9	}
10	}
11	return true;
12	}
13
14	fn sliceU8(input: [u8]) -> [u8] {
15	return input;
16	}
17
18	fn sliceI32(input: [i32]) -> [i32] {
19	return input;
20	}
21
22	fn sliceEqualU32(a: [u32], b: [u32]) -> bool {
23	if a.len <> b.len {
24	return false;
25	}
26	for i in 0..a.len {
27	if a[i] <> b[i] {
28	return false;
29	}
30	}
31	return true;
32	}
33
34	fn sliceEqualI32(a: [i32], b: [i32]) -> bool {
35	if a.len <> b.len {
36	return false;
37	}
38	for i in 0..a.len {
39	if a[i] <> b[i] {
40	return false;
41	}
42	}
43	return true;
44	}
45
46	fn sliceEqual1() -> bool {
47	let a1: [u32; 3] = [9, 42, 3];
48
49	let s1: *[u32] = &a1[..];
50	let s2: *[u32] = &a1[..];
51
52	return s1 == s2 and sliceEqualU32(s1, s2);
53	}
54
55	fn sliceEqual2() -> bool {
56	let a1: [u32; 3] = [9, 42, 3];
57
58	let s1: *[u32] = &a1[1..];
59	let s2: *[u32] = &a1[1..];
60
61	return s1 == s2 and sliceEqualU32(s1, s2);
62	}
63
64	fn sliceEqual3() -> bool {
65	let a1: [u32; 3] = [9, 42, 3];
66
67	let s1: *[u32] = &a1[..1];
68	let s2: *[u32] = &a1[..1];
69
70	return s1 == s2 and sliceEqualU32(s1, s2);
71	}
72
73	fn sliceEqual4() -> bool {
74	let a1: [u32; 3] = [9, 42, 3];
75
76	let s1: *[u32] = &a1[2..];
77	let s2: *[u32] = &a1[2..];
78
79	return s1 == s2 and sliceEqualU32(s1, s2);
80	}
81
82	fn sliceNotEqualSameArray1() -> bool {
83	let a1: [u32; 3] = [42, 8, 3];
84
85	let s1: *[u32] = &a1[..2];
86	let s2: *[u32] = &a1[1..3];
87
88	return s1 <> s2 and not sliceEqualU32(s1, s2);
89	}
90
91	fn sliceNotEqualSameArray2() -> bool {
92	let a1: [u32; 3] = [42, 8, 3];
93
94	let s1: *[u32] = &a1[..2];
95	let s2: *[u32] = &a1[..3];
96
97	return s1 <> s2 and not sliceEqualU32(s1, s2);
98	}
99
100	fn sliceEqualDifferentArray() -> bool {
101	let a1: [u32; 3] = [42, 8, 3];
102	let a2: [u32; 3] = [42, 8, 3];
103
104	let s1: *[u32] = &a1[..];
105	let s2: *[u32] = &a2[..];
106
107	return sliceEqualU32(s1, s2) and s1 <> s2;
108	}
109
110	fn sliceEqualString1() -> bool {
111	let s1: *[u8] = "ABC";
112	let s2: *[u8] = "ABC";
113
114	return memEq(s1, s2);
115	}
116
117	fn sliceEqualString2() -> bool {
118	let s1: *[u8] = "ABC";
119	let s2: *[u8] = "DEF";
120
121	return not memEq(s1, s2);
122	}
123
124	fn sliceEqualString3() -> bool {
125	let a1: [u8; 3] = ['A', 'B', 'C'];
126	let s1: *[u8] = &a1[..];
127	let s2: *[u8] = "ABC";
128
129	return memEq(s1, s2)
130	and memEq(s1, "ABC")
131	and memEq(&a1[..], "ABC");
132	}
133
134	fn sliceEqualString4() -> bool {
135	let s1: *[u8] = "ABC";
136	let s2: *[u8] = &['A', 'B', 'C'];
137
138	return memEq(s1, s2);
139	}
140
141	fn sliceEqualString5() -> bool {
142	let s1: *[u8] = "ABC";
143
144	// Sub-slicing a slice currently trips a separate compiler bug.
145	// Keep this check focused on slice equality behavior itself.
146	return memEq(s1, "ABC");
147	}
148
149	fn sliceNotEqualU8() -> bool {
150	let a: [u8; 3] = [1, 2, 3];
151	let b: [u8; 3] = [1, 2, 4];
152	let s: *[u8] = &[1, 2, 3];
153
154	return not memEq(s, &[1, 2, 4])
155	and not memEq(s, &[1, 0, 3])
156	and not memEq("ABC", "ABCD")
157	and not memEq("ABC", "ABD")
158	and not memEq(&a[..], &a[1..])
159	and not memEq(&a[..], &b[..])
160	and not memEq(&a[..], &[1, 3, 3]);
161	}
162
163	fn sliceNotEqualU16() -> bool {
164	let a: [u16; 3] = [1, 2, 3];
165	let b: [u16; 3] = [1, 2, 4];
166	let s: *[u16] = &[1, 2, 3];
167
168	return s <> &[1, 2, 4]
169	and s <> &[1, 0, 3]
170	and &a[..] <> &a[1..]
171	and &a[..] <> &b[..]
172	and &a[..] <> &[1, 3, 3];
173	}
174
175	fn sliceReturnEqual() -> bool {
176	return memEq(sliceU8("ABC"), "ABC")
177	and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);
178	}
179
180	@default fn main() -> i32 {
181	assert sliceEqual1();
182	assert sliceEqual2();
183	assert sliceEqual3();
184	assert sliceEqual4();
185	assert sliceEqualString1();
186	assert sliceEqualString2();
187	assert sliceEqualString3();
188	assert sliceEqualString4();
189	assert sliceEqualString5();
190	assert sliceNotEqualSameArray1();
191	assert sliceNotEqualSameArray2();
192	assert sliceEqualDifferentArray();
193	assert sliceNotEqualU8();
194	assert sliceNotEqualU16();
195	assert sliceReturnEqual();
196
197	return 0;
198	}