nandi.uk
Fork of daniellemaywood.uk/gleam — Wasm codegen work
8.1 kB
570 lines
1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: 2021 The Gleam contributors
3
4use crate::assert_erl;
5
6#[test]
7fn bit_array() {
8 assert_erl!(
9 r#"pub fn main() {
10 let a = 1
11 let simple = <<1, a>>
12 let complex = <<4:int-big, 5.0:little-float, 6:native-int>>
13 let assert <<7:2, 8:size(3), b:bytes-size(4)>> = <<1>>
14 let assert <<c:8-unit(1), d:bytes-size(2)-unit(2)>> = <<1>>
15
16 simple
17}
18"#
19 );
20}
21
22#[test]
23fn bit_array_float() {
24 assert_erl!(
25 r#"pub fn main() {
26 let b = 16
27 let floats = <<1.0:16-float, 5.0:float-32, 6.0:float-64-little, 1.0:float-size(b)>>
28 let assert <<1.0:16-float, 5.0:float-32, 6.0:float-64-little, 1.0:float-size(b)>> = floats
29}"#
30 );
31}
32
33#[test]
34fn bit_array1() {
35 assert_erl!(
36 r#"pub fn x() { 2 }
37pub fn main() {
38 let a = -1
39 let b = <<a:unit(2)-size(a * 2), a:size(3 + x())-unit(1)>>
40
41 b
42}
43"#
44 );
45}
46
47#[test]
48fn bit_array2() {
49 assert_erl!(
50 r#"pub fn main() {
51 let a = 1
52 let assert <<b, 1>> = <<1, a>>
53 b
54}
55"#
56 );
57}
58
59#[test]
60fn bit_array3() {
61 assert_erl!(
62 r#"pub fn main() {
63 let a = <<"test":utf8>>
64 let assert <<b:utf8_codepoint, "st":utf8>> = a
65 b
66}
67"#
68 );
69}
70
71#[test]
72fn bit_array4() {
73 assert_erl!(
74 r#"fn x() { 1 }
75pub fn main() {
76 let a = <<x():int>>
77 a
78}
79"#
80 );
81}
82
83#[test]
84fn bit_array5() {
85 assert_erl!(
86 r#"const bit_size = 8
87pub fn main() {
88 let a = <<10:size(bit_size)>>
89 a
90}
91"#
92 );
93}
94
95#[test]
96fn bit_array_discard() {
97 // https://github.com/gleam-lang/gleam/issues/704
98
99 assert_erl!(
100 r#"
101pub fn bit_array_discard(x) -> Bool {
102 case x {
103 <<_:utf8, rest:bytes>> -> True
104 _ -> False
105 }
106}
107 "#
108 );
109}
110
111#[test]
112fn bit_array_discard1() {
113 assert_erl!(
114 r#"
115pub fn bit_array_discard(x) -> Bool {
116 case x {
117 <<_discardme:utf8, rest:bytes>> -> True
118 _ -> False
119 }
120}
121"#
122 );
123}
124
125#[test]
126fn bit_array_declare_and_use_var() {
127 assert_erl!(
128 r#"pub fn go(x) {
129 let assert <<name_size:8, name:bytes-size(name_size)>> = x
130 name
131}"#
132 );
133}
134
135// https://github.com/gleam-lang/gleam/issues/3050
136#[test]
137fn unicode_bit_array_1() {
138 assert_erl!(
139 r#"
140 pub fn main() {
141 let emoji = "\u{1F600}"
142 let arr = <<emoji:utf8>>
143}"#
144 );
145}
146
147#[test]
148fn unicode_bit_array_2() {
149 assert_erl!(
150 r#"
151 pub fn main() {
152 let arr = <<"\u{1F600}":utf8>>
153}"#
154 );
155}
156
157#[test]
158fn bit_array_literal_string_constant_is_treated_as_utf8() {
159 assert_erl!(
160 r#"
161const a = <<"hello", " ", "world">>
162pub fn main() { a }
163"#
164 );
165}
166
167#[test]
168fn bit_array_literal_string_is_treated_as_utf8() {
169 assert_erl!(
170 r#"
171pub fn main() {
172 <<"hello", " ", "world">>
173}"#
174 );
175}
176
177#[test]
178fn bit_array_literal_string_pattern_is_treated_as_utf8() {
179 assert_erl!(
180 r#"
181pub fn main() {
182 case <<>> {
183 <<"a", "b", _:bits>> -> 1
184 _ -> 2
185 }
186}"#
187 );
188}
189
190#[test]
191fn discard_utf8_pattern() {
192 assert_erl!(
193 r#"
194pub fn main() {
195 let assert <<_:utf8, rest:bits>> = <<>>
196}"#
197 );
198}
199
200// https://github.com/gleam-lang/gleam/issues/3944
201#[test]
202fn pipe_size_segment() {
203 assert_erl!(
204 "
205pub fn main() {
206 <<0xAE:size(5 |> identity)>>
207}
208
209fn identity(x) {
210 x
211}
212"
213 );
214}
215
216#[test]
217fn utf16_codepoint_little_endian() {
218 assert_erl!(
219 "
220pub fn go(codepoint) {
221 <<codepoint:utf16_codepoint-little>>
222}
223"
224 );
225}
226
227#[test]
228fn utf32_codepoint_little_endian() {
229 assert_erl!(
230 "
231pub fn go(codepoint) {
232 <<codepoint:utf32_codepoint-little>>
233}
234"
235 );
236}
237
238#[test]
239fn pattern_match_utf16_codepoint_little_endian() {
240 assert_erl!(
241 "
242pub fn go(x) {
243 let assert <<codepoint:utf16_codepoint-little>> = x
244 codepoint
245}
246"
247 );
248}
249
250#[test]
251fn pattern_match_utf32_codepoint_little_endian() {
252 assert_erl!(
253 "
254pub fn go(x) {
255 let assert <<codepoint:utf32_codepoint-little>> = x
256 codepoint
257}
258"
259 );
260}
261
262#[test]
263fn operator_in_pattern_size() {
264 assert_erl!(
265 "
266pub fn main() {
267 let assert <<len, payload:size(len * 8 - 8)>> = <<>>
268}
269"
270 );
271}
272
273#[test]
274fn operator_in_pattern_size2() {
275 assert_erl!(
276 "
277pub fn main() {
278 let assert <<len, payload:size(len / 8 - 1)>> = <<>>
279}
280"
281 );
282}
283
284#[test]
285fn operator_in_pattern_size3() {
286 assert_erl!(
287 "
288pub fn main() {
289 let additional = 10
290 let assert <<len, payload:size(len + additional * 8)>> = <<>>
291}
292"
293 );
294}
295
296#[test]
297fn subtraction_in_pattern_size_is_left_associative() {
298 assert_erl!(
299 "
300pub fn main() {
301 let a = 10
302 let b = 3
303 let c = 2
304 let assert <<_:bytes-size(a - b - c)>> = <<>>
305}
306"
307 );
308}
309
310#[test]
311fn multiplication_in_pattern_size_is_left_associative() {
312 assert_erl!(
313 "
314pub fn main() {
315 let a = 2
316 let b = 3
317 let c = 4
318 let assert <<_:bytes-size(a * b * c)>> = <<>>
319}
320"
321 );
322}
323
324#[test]
325fn block_in_pattern_size() {
326 assert_erl!(
327 "
328pub fn main() {
329 let assert <<len, payload:size({ len - 1 } * 8)>> = <<>>
330}
331"
332 );
333}
334
335#[test]
336fn non_byte_aligned_size_calculation() {
337 assert_erl!(
338 "
339pub fn main() {
340 case <<>> {
341 <<a:1, b:3, c:size(b - 2)>> -> c + b
342 _ -> 1
343 }
344}
345"
346 );
347}
348
349#[test]
350fn unicode_character_encoding_in_bit_array_pattern_segment() {
351 assert_erl!(
352 r#"
353pub fn main() -> Nil {
354 let wibble = <<"\u{00A9}wibble":utf8>>
355 let _bits = case wibble {
356 <<"\u{00A9}":utf8, rest: bits>> -> rest
357 _ -> wibble
358 }
359 Nil
360}
361"#
362 );
363}
364
365#[test]
366fn size_8_literal_test() {
367 assert_erl!(
368 "pub fn size_8_literal_test() {
369 <<257:size(8)>>
370}"
371 );
372}
373
374#[test]
375fn size_8_variable_test() {
376 assert_erl!(
377 "pub fn size_8_variable_test() {
378 let i = 257
379 <<i:size(8)>>
380}"
381 );
382}
383
384#[test]
385fn size_16_literal_test() {
386 assert_erl!(
387 "pub fn size_16_literal_test() {
388 <<257:size(16)>>
389}"
390 );
391}
392
393#[test]
394fn size_16_variable_test() {
395 assert_erl!(
396 "pub fn size_16_variable_test() {
397 let i = 257
398 <<i:size(16)>>
399}"
400 );
401}
402
403#[test]
404fn size_unit_test() {
405 assert_erl!(
406 "pub fn size_16_variable_test() {
407 let i = 257
408 <<i:size(4)-unit(16)>>
409}"
410 );
411}
412
413#[test]
414fn negative_size_test() {
415 assert_erl!(
416 "pub fn size_16_variable_test() {
417 let i = 257
418 <<i:size(-1)>>
419}"
420 );
421}
422
423#[test]
424fn literal_utf8_string() {
425 assert_erl!(
426 r#"
427pub fn go() {
428 <<"wibble":utf8>>
429}
430"#
431 )
432}
433
434#[test]
435fn variable_utf8_string() {
436 assert_erl!(
437 r#"
438pub fn go(wibble: String) {
439 <<wibble:utf8>>
440}
441"#
442 )
443}
444
445#[test]
446fn literal_utf16_little_string() {
447 assert_erl!(
448 r#"
449pub fn go() {
450 <<"wibble":utf16-little>>
451}
452"#
453 )
454}
455
456#[test]
457fn variable_utf16_little_string() {
458 assert_erl!(
459 r#"
460pub fn go(wibble: String) {
461 <<wibble:utf16-little>>
462}
463"#
464 )
465}
466
467#[test]
468fn literal_utf16_big_string() {
469 assert_erl!(
470 r#"
471pub fn go() {
472 <<"wibble":utf16-big>>
473}
474"#
475 )
476}
477
478#[test]
479fn variable_utf16_big_string() {
480 assert_erl!(
481 r#"
482pub fn go(wibble: String) {
483 <<wibble:utf16-big>>
484}
485"#
486 )
487}
488
489#[test]
490fn literal_utf32_little_string() {
491 assert_erl!(
492 r#"
493pub fn go() {
494 <<"wibble":utf32-little>>
495}
496"#
497 )
498}
499
500#[test]
501fn variable_utf32_little_string() {
502 assert_erl!(
503 r#"
504pub fn go(wibble: String) {
505 <<wibble:utf32-little>>
506}
507"#
508 )
509}
510
511#[test]
512fn literal_utf32_big_string() {
513 assert_erl!(
514 r#"
515pub fn go() {
516 <<"wibble":utf32-big>>
517}
518"#
519 )
520}
521
522#[test]
523fn variable_utf32_big_string() {
524 assert_erl!(
525 r#"
526pub fn go(wibble: String) {
527 <<wibble:utf32-big>>
528}
529"#
530 )
531}
532
533// https://github.com/gleam-lang/gleam/issues/5208
534#[test]
535fn unit_option_ignores_bytes() {
536 assert_erl!(
537 "
538pub fn main() {
539 let assert <<x:unit(2)-bytes-size(3)>> = <<1:6>>
540 x
541}
542"
543 );
544}
545
546#[test]
547fn unit_option_ignores_bytes_regardless_of_order() {
548 assert_erl!(
549 "
550pub fn main() {
551 let assert <<x:bytes-unit(2)-size(3)>> = <<1:6>>
552 x
553}
554"
555 );
556}
557
558#[test]
559// https://github.com/gleam-lang/gleam/issues/6020
560fn bit_array_segment_inside_block_with_size() {
561 assert_erl!(
562 "
563pub fn main() {
564 let a = 1
565 let b = 2
566 <<{ a + b }, { a + b }:size(16)>>
567}
568"
569 )
570}