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