daniellemaywood.uk
this repo has no description
giacomocavalieri.me
1use hexpm::version::Version;
2use pubgrub::Range;
3
4use crate::{
5 assert_js, assert_js_no_warnings_with_gleam_version, assert_js_warnings_with_gleam_version,
6 assert_ts_def,
7};
8
9#[test]
10fn empty() {
11 assert_js!(
12 r#"
13pub fn go() {
14 <<>>
15}
16"#,
17 );
18}
19
20#[test]
21fn one() {
22 assert_js!(
23 r#"
24pub fn go() {
25 <<256>>
26}
27"#,
28 );
29}
30
31#[test]
32fn two() {
33 assert_js!(
34 r#"
35pub fn go() {
36 <<256, 4>>
37}
38"#,
39 );
40}
41
42#[test]
43fn integer() {
44 assert_js!(
45 r#"
46pub fn go() {
47 <<256:int>>
48}
49"#,
50 );
51}
52
53#[test]
54fn float() {
55 assert_js!(
56 r#"
57pub fn go() {
58 <<1.1:float>>
59}
60"#,
61 );
62}
63
64#[test]
65fn float_big_endian() {
66 assert_js!(
67 r#"
68pub fn go() {
69 <<1.1:float-big>>
70}
71"#,
72 );
73}
74
75#[test]
76fn float_little_endian() {
77 assert_js!(
78 r#"
79pub fn go() {
80 <<1.1:float-little>>
81}
82"#,
83 );
84}
85
86#[test]
87fn float_sized() {
88 assert_js!(
89 r#"
90pub fn go() {
91 <<1.1:float-32>>
92}
93"#,
94 );
95}
96
97#[test]
98fn float_sized_big_endian() {
99 assert_js!(
100 r#"
101pub fn go() {
102 <<1.1:float-32-big>>
103}
104"#,
105 );
106}
107
108#[test]
109fn float_sized_little_endian() {
110 assert_js!(
111 r#"
112pub fn go() {
113 <<1.1:float-32-little>>
114}
115"#,
116 );
117}
118
119#[test]
120fn sized_constant_value() {
121 assert_js!(
122 r#"
123pub fn go() {
124 <<256:64>>
125}
126"#,
127 );
128}
129
130#[test]
131fn sized_dynamic_value() {
132 assert_js!(
133 r#"
134pub fn go(i: Int) {
135 <<i:64>>
136}
137"#,
138 );
139}
140
141#[test]
142fn sized_constant_value_positive_overflow() {
143 assert_js!(
144 r#"
145pub fn go() {
146 <<80_000:16>>
147}
148"#,
149 );
150}
151
152#[test]
153fn sized_constant_value_negative_overflow() {
154 assert_js!(
155 r#"
156pub fn go() {
157 <<-80_000:16>>
158}
159"#,
160 );
161}
162
163#[test]
164fn sized_constant_value_max_size_for_compile_time_evaluation() {
165 assert_js!(
166 r#"
167pub fn go() {
168 <<-1:48>>
169}
170"#,
171 );
172}
173
174#[test]
175fn sized_big_endian_constant_value() {
176 assert_js!(
177 r#"
178pub fn go() {
179 <<256:16-big>>
180}
181"#,
182 );
183}
184
185#[test]
186fn sized_big_endian_dynamic_value() {
187 assert_js!(
188 r#"
189pub fn go(i: Int) {
190 <<i:16-big>>
191}
192"#,
193 );
194}
195
196#[test]
197fn sized_little_endian_constant_value() {
198 assert_js!(
199 r#"
200pub fn go() {
201 <<256:16-little>>
202}
203"#,
204 );
205}
206
207#[test]
208fn sized_little_endian_dynamic_value() {
209 assert_js!(
210 r#"
211pub fn go(i: Int) {
212 <<i:16-little>>
213}
214"#,
215 );
216}
217
218#[test]
219fn explicit_sized_constant_value() {
220 assert_js!(
221 r#"
222pub fn go() {
223 <<256:size(32)>>
224}
225"#,
226 );
227}
228
229#[test]
230fn explicit_sized_dynamic_value() {
231 assert_js!(
232 r#"
233pub fn go(i: Int) {
234 <<i:size(32)>>
235}
236"#,
237 );
238}
239
240#[test]
241fn variable_sized() {
242 assert_js!(
243 r#"
244pub fn go(x, y) {
245 <<x:size(y)>>
246}
247"#,
248 );
249}
250
251#[test]
252fn variable() {
253 assert_js!(
254 r#"
255pub fn go(x) {
256 <<256, 4, x>>
257}
258"#,
259 );
260}
261
262#[test]
263fn utf8() {
264 assert_js!(
265 r#"
266pub fn go(x) {
267 <<256, 4, x, "Gleam":utf8>>
268}
269"#,
270 );
271}
272
273#[test]
274fn match_utf8_with_escape_chars() {
275 assert_js!(
276 r#"
277pub fn go(x) {
278 let assert <<"\"\\\r\n\t\f\u{1f600}">> = x
279}
280"#,
281 );
282}
283
284#[test]
285fn match_utf8() {
286 assert_js!(
287 r#"
288pub fn go(x) {
289 let assert <<"Gleam 👍":utf8>> = x
290}
291"#,
292 );
293}
294
295#[test]
296fn match_case_utf8_with_escape_chars() {
297 assert_js!(
298 r#"
299pub fn go(x) {
300 case x {
301 <<"\"\\\r\n\t\f\u{1f600}">> -> 1
302 _ -> 2
303 }
304}
305"#,
306 );
307}
308
309#[test]
310fn match_case_utf8() {
311 assert_js!(
312 r#"
313pub fn go(x) {
314 case x {
315 <<"Gleam 👍":utf8>> -> 1
316 _ -> 2
317 }
318}
319"#,
320 );
321}
322
323#[test]
324fn utf8_codepoint() {
325 assert_js!(
326 r#"
327pub fn go(x) {
328 <<x:utf8_codepoint, "Gleam":utf8>>
329}
330"#,
331 );
332}
333
334#[test]
335fn utf8_codepoint_typescript() {
336 assert_ts_def!(
337 r#"
338pub fn go(x) {
339 <<x:utf8_codepoint, "Gleam":utf8>>
340}
341"#,
342 );
343}
344
345#[test]
346fn bit_string() {
347 assert_js!(
348 r#"
349pub fn go(x) {
350 <<x:bits>>
351}
352"#,
353 );
354}
355
356#[test]
357fn bits() {
358 assert_js!(
359 r#"
360pub fn go(x) {
361 <<x:bits>>
362}
363"#,
364 );
365}
366
367#[test]
368fn bit_array_sliced() {
369 assert_js!(
370 r#"
371pub fn go(x) {
372 <<<<0xAB>>:bits-4>>
373}
374"#,
375 );
376}
377
378#[test]
379fn bit_array_dynamic_slice() {
380 assert_js!(
381 r#"
382pub fn go(x) {
383 let i = 4
384 <<<<0xAB>>:bits-size(i)>>
385}
386"#,
387 );
388}
389
390#[test]
391fn bit_string_typescript() {
392 assert_ts_def!(
393 r#"
394pub fn go(x) {
395 <<x:bits>>
396}
397"#,
398 );
399}
400
401#[test]
402fn bits_typescript() {
403 assert_ts_def!(
404 r#"
405pub fn go(x) {
406 <<x:bits>>
407}
408"#,
409 );
410}
411
412#[test]
413fn empty_match() {
414 assert_js!(
415 r#"
416pub fn go(x) {
417 let assert <<>> = x
418}
419"#,
420 );
421}
422
423#[test]
424fn case_empty_match() {
425 assert_js!(
426 r#"
427pub fn go(x) {
428 case x {
429 <<>> -> 1
430 _ -> 2
431 }
432}
433"#,
434 );
435}
436
437#[test]
438fn match_bytes() {
439 assert_js!(
440 r#"
441pub fn go(x) {
442 let assert <<1, y>> = x
443}
444"#,
445 );
446}
447
448#[test]
449fn case_match_bytes() {
450 assert_js!(
451 r#"
452pub fn go(x) {
453 case x {
454 <<1, y>> -> y
455 _ -> 1
456 }
457}
458"#,
459 );
460}
461
462#[test]
463fn match_sized() {
464 assert_js!(
465 r#"
466pub fn go(x) {
467 let assert <<a:16, b:8>> = x
468}
469"#,
470 );
471}
472
473#[test]
474fn case_match_sized() {
475 assert_js!(
476 r#"
477pub fn go(x) {
478 case x {
479 <<a:16, b:8>> -> a + b
480 _ -> 1
481 }
482}
483"#,
484 );
485}
486
487#[test]
488fn match_sized_unaligned() {
489 assert_js!(
490 r#"
491pub fn go(x) {
492 let assert <<a:17, b:7>> = x
493}
494"#,
495 );
496}
497
498#[test]
499fn case_match_sized_unaligned() {
500 assert_js!(
501 r#"
502pub fn go(x) {
503 case x {
504 <<a:17, b:7>> -> b * 2
505 _ -> 1
506 }
507}
508"#,
509 );
510}
511
512#[test]
513fn match_sized_constant_pattern() {
514 assert_js!(
515 r#"
516pub fn go(x) {
517 let assert <<1234:16, 123:8>> = x
518}
519"#,
520 );
521}
522
523#[test]
524fn case_match_sized_constant_pattern() {
525 assert_js!(
526 r#"
527pub fn go(x) {
528 case x {
529 <<1234:16, 123:8>> -> 1
530 _ -> 2
531 }
532}
533"#,
534 );
535}
536
537#[test]
538fn match_unsigned() {
539 assert_js!(
540 r#"
541pub fn go(x) {
542 let assert <<a:unsigned>> = x
543}
544"#,
545 );
546}
547
548#[test]
549fn case_match_unsigned() {
550 assert_js!(
551 r#"
552pub fn go(x) {
553 case x {
554 <<a:unsigned>> -> a
555 _ -> 1
556 }
557}
558"#,
559 );
560}
561
562#[test]
563fn match_unsigned_constant_pattern() {
564 assert_js!(
565 r#"
566pub fn go(x) {
567 let assert <<-2:unsigned>> = x
568}
569"#,
570 );
571}
572
573#[test]
574fn case_match_unsigned_constant_pattern() {
575 assert_js!(
576 r#"
577pub fn go(x) {
578 case x {
579 <<-2:unsigned>> -> 1
580 _ -> 2
581 }
582}
583"#,
584 );
585}
586
587#[test]
588fn match_signed() {
589 assert_js!(
590 r#"
591pub fn go(x) {
592 let assert <<a:signed>> = x
593}
594"#,
595 );
596}
597
598#[test]
599fn case_match_signed() {
600 assert_js!(
601 r#"
602pub fn go(x) {
603 case x {
604 <<a:signed>> -> a
605 _ -> 1
606 }
607}
608"#,
609 );
610}
611
612#[test]
613fn match_signed_constant_pattern() {
614 assert_js!(
615 r#"
616pub fn go(x) {
617 let assert <<-1:signed>> = x
618}
619"#,
620 );
621}
622
623#[test]
624fn case_match_signed_constant_pattern() {
625 assert_js!(
626 r#"
627pub fn go(x) {
628 case x {
629 <<-1:signed>> -> 1
630 _ -> 2
631 }
632}
633"#,
634 );
635}
636
637#[test]
638fn match_sized_big_endian() {
639 assert_js!(
640 r#"
641pub fn go(x) {
642 let assert <<a:16-big>> = x
643}
644"#,
645 );
646}
647
648#[test]
649fn case_match_sized_big_endian() {
650 assert_js!(
651 r#"
652pub fn go(x) {
653 case x {
654 <<a:16-big>> -> a
655 _ -> 1
656 }
657}
658"#,
659 );
660}
661
662#[test]
663fn match_sized_big_endian_constant_pattern() {
664 assert_js!(
665 r#"
666pub fn go(x) {
667 let assert <<1234:16-big>> = x
668}
669"#,
670 );
671}
672
673#[test]
674fn case_match_sized_big_endian_constant_pattern() {
675 assert_js!(
676 r#"
677pub fn go(x) {
678 case x {
679 <<1234:16-big>> -> 1
680 _ -> 2
681 }
682}
683"#,
684 );
685}
686
687#[test]
688fn match_sized_little_endian() {
689 assert_js!(
690 r#"
691pub fn go(x) {
692 let assert <<a:16-little>> = x
693}
694"#,
695 );
696}
697
698#[test]
699fn case_match_sized_little_endian() {
700 assert_js!(
701 r#"
702pub fn go(x) {
703 case x {
704 <<a:16-little>> -> a
705 _ -> 1
706 }
707}
708"#,
709 );
710}
711
712#[test]
713fn match_sized_little_endian_constant_pattern() {
714 assert_js!(
715 r#"
716pub fn go(x) {
717 let assert <<1234:16-little>> = x
718}
719"#,
720 );
721}
722
723#[test]
724fn case_match_sized_little_endian_constant_pattern() {
725 assert_js!(
726 r#"
727pub fn go(x) {
728 case x {
729 <<1234:16-little>> -> 1
730 _ -> 2
731 }
732}
733"#,
734 );
735}
736
737#[test]
738fn match_sized_big_endian_unsigned() {
739 assert_js!(
740 r#"
741pub fn go(x) {
742 let assert <<a:16-big-unsigned>> = x
743}
744"#,
745 );
746}
747
748#[test]
749fn case_match_sized_big_endian_unsigned() {
750 assert_js!(
751 r#"
752pub fn go(x) {
753 case x {
754 <<a:16-big-unsigned>> -> a
755 _ -> 1
756 }
757}
758"#,
759 );
760}
761
762#[test]
763fn match_sized_big_endian_unsigned_constant_pattern() {
764 assert_js!(
765 r#"
766pub fn go(x) {
767 let assert <<1234:16-big-unsigned>> = x
768}
769"#,
770 );
771}
772
773#[test]
774fn case_match_sized_big_endian_unsigned_constant_pattern() {
775 assert_js!(
776 r#"
777pub fn go(x) {
778 case x {
779 <<1234:16-big-unsigned>> -> 1
780 _ -> 2
781 }
782}
783"#,
784 );
785}
786
787#[test]
788fn match_sized_big_endian_signed() {
789 assert_js!(
790 r#"
791pub fn go(x) {
792 let assert <<a:16-big-signed>> = x
793}
794"#,
795 );
796}
797
798#[test]
799fn case_match_sized_big_endian_signed() {
800 assert_js!(
801 r#"
802pub fn go(x) {
803 case x {
804 <<a:16-big-signed>> -> a
805 _ -> 1
806 }
807}
808"#,
809 );
810}
811
812#[test]
813fn match_sized_big_endian_signed_constant_pattern() {
814 assert_js!(
815 r#"
816pub fn go(x) {
817 let assert <<1234:16-big-signed>> = x
818}
819"#,
820 );
821}
822
823#[test]
824fn case_match_sized_big_endian_signed_constant_pattern() {
825 assert_js!(
826 r#"
827pub fn go(x) {
828 case x {
829 <<1234:16-big-signed>> -> 1
830 _ -> 2
831 }
832}
833"#,
834 );
835}
836
837#[test]
838fn match_sized_little_endian_unsigned() {
839 assert_js!(
840 r#"
841pub fn go(x) {
842 let assert <<a:16-little-unsigned>> = x
843}
844"#,
845 );
846}
847
848#[test]
849fn case_match_sized_little_endian_unsigned() {
850 assert_js!(
851 r#"
852pub fn go(x) {
853 case x {
854 <<a:16-little-unsigned>> -> a
855 _ -> 1
856 }
857}
858"#,
859 );
860}
861
862#[test]
863fn match_sized_little_endian_unsigned_constant_pattern() {
864 assert_js!(
865 r#"
866pub fn go(x) {
867 let assert <<1234:16-little-unsigned>> = x
868}
869"#,
870 );
871}
872
873#[test]
874fn case_match_sized_little_endian_unsigned_constant_pattern() {
875 assert_js!(
876 r#"
877pub fn go(x) {
878 case x {
879 <<1234:16-little-unsigned>> -> 1
880 _ -> 2
881 }
882}
883"#,
884 );
885}
886
887#[test]
888fn match_sized_little_endian_signed() {
889 assert_js!(
890 r#"
891pub fn go(x) {
892 let assert <<a:16-little-signed>> = x
893}
894"#,
895 );
896}
897
898#[test]
899fn case_match_sized_little_endian_signed() {
900 assert_js!(
901 r#"
902pub fn go(x) {
903 case x {
904 <<a:16-little-signed>> -> a
905 _ -> 1
906 }
907}
908"#,
909 );
910}
911
912#[test]
913fn match_sized_little_endian_signed_constant_pattern() {
914 assert_js!(
915 r#"
916pub fn go(x) {
917 let assert <<1234:16-little-signed>> = x
918}
919"#,
920 );
921}
922
923#[test]
924fn case_match_sized_little_endian_signed_constant_pattern() {
925 assert_js!(
926 r#"
927pub fn go(x) {
928 case x {
929 <<1234:16-little-signed>> -> 1
930 _ -> 2
931 }
932}
933"#,
934 );
935}
936
937#[test]
938fn match_dynamic_size() {
939 assert_js!(
940 r#"
941pub fn go(x) {
942 let n = 16
943 let assert <<a:size(n)>> = x
944}
945"#
946 );
947}
948
949#[test]
950fn case_match_dynamic_size() {
951 assert_js!(
952 r#"
953pub fn go(x) {
954 let n = 16
955 case x {
956 <<a:size(n)>> -> a
957 _ -> 1
958 }
959}
960"#
961 );
962}
963
964#[test]
965fn match_dynamic_size_with_other_segments() {
966 assert_js!(
967 r#"
968pub fn go(x) {
969 let n = 16
970 let m = 32
971 let assert <<first:size(8), a:size(n), b:size(m), rest:bits>> = x
972}
973"#
974 );
975}
976
977#[test]
978fn case_match_dynamic_size_with_other_segments() {
979 assert_js!(
980 r#"
981pub fn go(x) {
982 let n = 16
983 let m = 32
984 case x {
985 <<first:size(8), a:size(n), b:size(m), rest:bits>> -> first + a + b
986 _ -> 1
987 }
988}
989"#
990 );
991}
992
993#[test]
994fn match_dynamic_size_shadowed_variable() {
995 assert_js!(
996 r#"
997pub fn go(x) {
998 let n = 16
999 let n = 5
1000 let assert <<a:size(n)>> = x
1001}
1002"#
1003 );
1004}
1005
1006#[test]
1007fn case_match_dynamic_size_shadowed_variable() {
1008 assert_js!(
1009 r#"
1010pub fn go(x) {
1011 let n = 16
1012 let n = 5
1013 case x {
1014 <<a:size(n)>> -> a
1015 _ -> 1
1016 }
1017}
1018"#
1019 );
1020}
1021
1022#[test]
1023fn match_dynamic_size_literal_value() {
1024 assert_js!(
1025 r#"
1026pub fn go(x) {
1027 let n = 8
1028 let assert <<a:size(n), 0b010101:size(8)>> = x
1029}
1030"#
1031 );
1032}
1033
1034#[test]
1035fn case_match_dynamic_size_literal_value() {
1036 assert_js!(
1037 r#"
1038pub fn go(x) {
1039 let n = 8
1040 case x {
1041 <<a:size(n), 0b010101:size(8)>> -> a
1042 _ -> 1
1043 }
1044}
1045"#
1046 );
1047}
1048
1049#[test]
1050fn match_dynamic_bits_size() {
1051 assert_js!(
1052 r#"
1053pub fn go(x) {
1054 let n = 16
1055 let assert <<a:bits-size(n)>> = x
1056}
1057"#
1058 );
1059}
1060
1061#[test]
1062fn case_match_dynamic_bits_size() {
1063 assert_js!(
1064 r#"
1065pub fn go(x) {
1066 let n = 16
1067 case x {
1068 <<a:bits-size(n)>> -> a
1069 _ -> x
1070 }
1071}
1072"#
1073 );
1074}
1075
1076#[test]
1077fn match_dynamic_bytes_size() {
1078 assert_js!(
1079 r#"
1080pub fn go(x) {
1081 let n = 3
1082 let assert <<a:bytes-size(n)>> = x
1083}
1084"#
1085 );
1086}
1087
1088#[test]
1089fn case_match_dynamic_bytes_size() {
1090 assert_js!(
1091 r#"
1092pub fn go(x) {
1093 let n = 3
1094 case x {
1095 <<a:bytes-size(n)>> -> a
1096 _ -> x
1097 }
1098}
1099"#
1100 );
1101}
1102
1103#[test]
1104fn discard_sized() {
1105 assert_js!(
1106 r#"
1107pub fn go(x) {
1108 let assert <<_:16, _:8>> = x
1109 let assert <<_:16-little-signed, _:8>> = x
1110}
1111"#,
1112 );
1113}
1114
1115#[test]
1116fn case_discard_sized() {
1117 assert_js!(
1118 r#"
1119pub fn go(x) {
1120 case x {
1121 <<_:16, _:8>> -> 1
1122 _ -> 2
1123 }
1124 case x {
1125 <<_:16-little-signed, _:8>> -> 1
1126 _ -> 2
1127 }
1128}
1129"#,
1130 );
1131}
1132
1133#[test]
1134fn match_sized_value() {
1135 assert_js!(
1136 r#"
1137pub fn go(x) {
1138 let assert <<i:16>> = x
1139}
1140"#,
1141 );
1142}
1143
1144#[test]
1145fn case_match_sized_value() {
1146 assert_js!(
1147 r#"
1148pub fn go(x) {
1149 case x {
1150 <<i:16>> -> i
1151 _ -> 1
1152 }
1153}
1154"#,
1155 );
1156}
1157
1158#[test]
1159fn match_sized_value_constant_pattern() {
1160 assert_js!(
1161 r#"
1162pub fn go(x) {
1163 let assert <<258:16>> = x
1164}
1165"#,
1166 );
1167}
1168
1169#[test]
1170fn case_match_sized_value_constant_pattern() {
1171 assert_js!(
1172 r#"
1173pub fn go(x) {
1174 case x {
1175 <<258:16>> -> 1
1176 _ -> 2
1177 }
1178}
1179"#,
1180 );
1181}
1182
1183#[test]
1184fn match_float() {
1185 assert_js!(
1186 r#"
1187pub fn go(x) {
1188 let assert <<a:float, b:int>> = x
1189}
1190"#,
1191 );
1192}
1193
1194#[test]
1195fn case_match_float() {
1196 assert_js!(
1197 r#"
1198pub fn go(x) {
1199 case x {
1200 <<a:float, b:int>> -> #(a, b)
1201 _ -> #(1.1, 2)
1202 }
1203}
1204"#,
1205 );
1206}
1207
1208#[test]
1209fn match_float_big_endian() {
1210 assert_js!(
1211 r#"
1212pub fn go(x) {
1213 let assert <<a:float-big, b:int>> = x
1214}
1215"#,
1216 );
1217}
1218
1219#[test]
1220fn case_match_float_big_endian() {
1221 assert_js!(
1222 r#"
1223pub fn go(x) {
1224 case x {
1225 <<a:float-big, b:int>> -> #(a, b)
1226 _ -> #(1.1, 1)
1227 }
1228}
1229"#,
1230 );
1231}
1232
1233#[test]
1234fn match_float_little_endian() {
1235 assert_js!(
1236 r#"
1237pub fn go(x) {
1238 let assert <<a:float-little, b:int>> = x
1239}
1240"#,
1241 );
1242}
1243
1244#[test]
1245fn case_match_float_little_endian() {
1246 assert_js!(
1247 r#"
1248pub fn go(x) {
1249 case x {
1250 <<a:float-little, b:int>> -> #(a, b)
1251 _ -> #(1.1, 2)
1252 }
1253}
1254"#,
1255 );
1256}
1257
1258#[test]
1259fn match_float_sized() {
1260 assert_js!(
1261 r#"
1262pub fn go(x) {
1263 let assert <<a:float-32, b:int>> = x
1264}
1265"#,
1266 );
1267}
1268
1269#[test]
1270fn case_match_float_sized() {
1271 assert_js!(
1272 r#"
1273pub fn go(x) {
1274 case x {
1275 <<a:float-32, b:int>> -> #(a, b)
1276 _ -> #(1.1, 2)
1277 }
1278}
1279"#,
1280 );
1281}
1282
1283#[test]
1284fn match_float_sized_big_endian() {
1285 assert_js!(
1286 r#"
1287pub fn go(x) {
1288 let assert <<a:float-32-big, b:int>> = x
1289}
1290"#,
1291 );
1292}
1293
1294#[test]
1295fn case_match_float_sized_big_endian() {
1296 assert_js!(
1297 r#"
1298pub fn go(x) {
1299 case x {
1300 <<a:float-32-big, b:int>> -> #(a, b)
1301 _ -> #(1.1, 2)
1302 }
1303}
1304"#,
1305 );
1306}
1307
1308#[test]
1309fn match_float_sized_little_endian() {
1310 assert_js!(
1311 r#"
1312pub fn go(x) {
1313 let assert <<a:float-32-little, b:int>> = x
1314}
1315"#,
1316 );
1317}
1318
1319#[test]
1320fn case_match_float_sized_little_endian() {
1321 assert_js!(
1322 r#"
1323pub fn go(x) {
1324 case x {
1325 <<a:float-32-little, b:int>> -> #(a, b)
1326 _ -> #(1.1, 2)
1327 }
1328}
1329"#,
1330 );
1331}
1332
1333#[test]
1334fn match_literal_float() {
1335 assert_js!(
1336 r#"
1337pub fn go(x) {
1338 let assert <<1.4, b:int>> = x
1339}
1340"#,
1341 );
1342}
1343
1344#[test]
1345fn case_match_literal_float() {
1346 assert_js!(
1347 r#"
1348pub fn go(x) {
1349 case x {
1350 <<1.4, b:int>> -> 1
1351 _ -> 2
1352 }
1353}
1354"#,
1355 );
1356}
1357
1358#[test]
1359fn match_literal_unaligned_float() {
1360 assert_js!(
1361 r#"
1362pub fn go(x) {
1363 let n = 1
1364 let assert <<_:size(n), 1.1, _:bits>> = x
1365}
1366"#,
1367 );
1368}
1369
1370#[test]
1371fn case_match_literal_unaligned_float() {
1372 assert_js!(
1373 r#"
1374pub fn go(x) {
1375 let n = 1
1376 case x {
1377 <<_:size(n), 1.1, _:int>> -> 1
1378 _ -> 2
1379 }
1380}
1381"#,
1382 );
1383}
1384
1385#[test]
1386fn match_literal_aligned_float() {
1387 assert_js!(
1388 r#"
1389pub fn go(x) {
1390 let assert <<_, 1.1, _:bits>> = x
1391}
1392"#,
1393 );
1394}
1395
1396#[test]
1397fn case_match_literal_aligned_float() {
1398 assert_js!(
1399 r#"
1400pub fn go(x) {
1401 case x {
1402 <<_, 1.1, _:int>> -> 1
1403 _ -> 2
1404 }
1405}
1406"#,
1407 );
1408}
1409
1410#[test]
1411fn match_float_16_bit() {
1412 assert_js!(
1413 r#"
1414pub fn go(x) {
1415 let assert <<a:float-size(16)>> = x
1416}
1417"#
1418 );
1419}
1420
1421#[test]
1422fn case_match_float_16_bit() {
1423 assert_js!(
1424 r#"
1425pub fn go(x) {
1426 case x {
1427 <<a:float-size(16)>> -> a
1428 _ -> 1.1
1429 }
1430}
1431"#
1432 );
1433}
1434
1435#[test]
1436fn match_rest() {
1437 assert_js!(
1438 r#"
1439pub fn go(x) {
1440 let assert <<_, b:bytes>> = <<1,2,3>>
1441}
1442"#,
1443 );
1444}
1445
1446#[test]
1447fn case_match_rest() {
1448 assert_js!(
1449 r#"
1450pub fn go(x) {
1451 case <<1, 2, 3>> {
1452 <<_, b:bytes>> -> b
1453 _ -> x
1454 }
1455}
1456"#,
1457 );
1458}
1459
1460#[test]
1461fn match_bytes_with_size() {
1462 assert_js!(
1463 r#"
1464pub fn go(x) {
1465 let assert <<f:bytes-2>> = <<1, 2>>
1466}
1467"#,
1468 );
1469}
1470
1471#[test]
1472fn case_match_bytes_with_size() {
1473 assert_js!(
1474 r#"
1475pub fn go(x) {
1476 case <<1, 2>> {
1477 <<f:bytes-2>> -> f
1478 _ -> x
1479 }
1480}
1481"#,
1482 );
1483}
1484
1485#[test]
1486fn match_bits_with_size() {
1487 assert_js!(
1488 r#"
1489pub fn go(x) {
1490 let assert <<_:4, f:bits-2, _:1>> = <<0x77:7>>
1491}
1492"#,
1493 );
1494}
1495
1496#[test]
1497fn case_match_bits_with_size() {
1498 assert_js!(
1499 r#"
1500pub fn go(x) {
1501 case <<0x77:7>> {
1502 <<_:4, f:bits-2, _:1>> -> f
1503 _ -> x
1504 }
1505}
1506"#,
1507 );
1508}
1509
1510#[test]
1511fn match_rest_bytes() {
1512 assert_js!(
1513 r#"
1514pub fn go(x) {
1515 let assert <<_, b:bytes>> = <<1,2,3>>
1516}
1517"#,
1518 );
1519}
1520
1521#[test]
1522fn case_match_rest_bytes() {
1523 assert_js!(
1524 r#"
1525pub fn go(x) {
1526 case x {
1527 <<_, b:bytes>> -> b
1528 _ -> x
1529 }
1530}
1531"#,
1532 );
1533}
1534
1535#[test]
1536fn match_rest_bits() {
1537 assert_js!(
1538 r#"
1539pub fn go(x) {
1540 let assert <<_, b:bits>> = <<1,2,3>>
1541}
1542"#,
1543 );
1544}
1545
1546#[test]
1547fn case_match_rest_bits() {
1548 assert_js!(
1549 r#"
1550pub fn go(x) {
1551 case x {
1552 <<_, b:bits>> -> b
1553 _ -> x
1554 }
1555}
1556"#,
1557 );
1558}
1559
1560#[test]
1561fn match_rest_bits_unaligned() {
1562 assert_js!(
1563 r#"
1564pub fn go(x) {
1565 let assert <<_:5, b:bits>> = <<1,2,3>>
1566}
1567"#,
1568 );
1569}
1570
1571#[test]
1572fn case_match_rest_bits_unaligned() {
1573 assert_js!(
1574 r#"
1575pub fn go(x) {
1576 case x {
1577 <<_:5, b:bits>> -> b
1578 _ -> x
1579 }
1580}
1581"#,
1582 );
1583}
1584
1585#[test]
1586fn match_binary_size() {
1587 assert_js!(
1588 r#"
1589pub fn go(x) {
1590 let assert <<_, a:2-bytes>> = x
1591 let assert <<_, b:bytes-size(2)>> = x
1592}
1593"#,
1594 );
1595}
1596
1597#[test]
1598fn case_match_binary_size() {
1599 assert_js!(
1600 r#"
1601pub fn go(x) {
1602 case x {
1603 <<_, a:2-bytes>> -> a
1604 _ -> x
1605 }
1606
1607 case x {
1608 <<_, b:bytes-size(2)>> -> b
1609 _ -> x
1610 }
1611}
1612"#,
1613 );
1614}
1615
1616#[test]
1617fn unaligned_int_expression_requires_v1_9() {
1618 assert_js_warnings_with_gleam_version!(
1619 Range::higher_than(Version::new(1, 8, 0)),
1620 "
1621pub fn main() {
1622 <<0:1>>
1623}
1624 ",
1625 );
1626}
1627
1628#[test]
1629fn bits_expression_does_not_require_v1_9() {
1630 assert_js_no_warnings_with_gleam_version!(
1631 Range::higher_than(Version::new(1, 8, 0)),
1632 "
1633pub fn main() {
1634 <<<<0>>:bits>>
1635}
1636 ",
1637 );
1638}
1639
1640#[test]
1641fn sized_bits_expression_requires_v1_9() {
1642 assert_js_warnings_with_gleam_version!(
1643 Range::higher_than(Version::new(1, 8, 0)),
1644 "
1645pub fn main() {
1646 <<<<0>>:bits-5>>
1647}
1648 ",
1649 );
1650}
1651
1652#[test]
1653fn unaligned_int_pattern_requires_v1_9() {
1654 assert_js_warnings_with_gleam_version!(
1655 Range::higher_than(Version::new(1, 8, 0)),
1656 "
1657pub fn main() {
1658 let assert <<_:3>> = <<0>>
1659}
1660 ",
1661 );
1662}
1663
1664#[test]
1665fn bits_pattern_requires_v1_9() {
1666 assert_js_warnings_with_gleam_version!(
1667 Range::higher_than(Version::new(1, 8, 0)),
1668 "
1669pub fn main() {
1670 let assert <<_:bits>> = <<0>>
1671}
1672 ",
1673 );
1674}
1675
1676#[test]
1677fn bytes_pattern_with_odd_size_does_not_require_v1_9() {
1678 assert_js_no_warnings_with_gleam_version!(
1679 Range::higher_than(Version::new(1, 8, 0)),
1680 "
1681pub fn main() {
1682 let assert <<_:bytes-3>> = <<0, 1, 2>>
1683}
1684 ",
1685 );
1686}
1687
1688#[test]
1689fn sized_bits_expression_with_javascript_external_does_not_require_v1_9() {
1690 assert_js_no_warnings_with_gleam_version!(
1691 Range::higher_than(Version::new(1, 8, 0)),
1692 r#"
1693@external(javascript, "test.mjs", "go")
1694pub fn go() -> BitArray {
1695 <<0:size(5)>>
1696}
1697 "#,
1698 );
1699}
1700
1701#[test]
1702fn bits_pattern_with_javascript_external_does_not_require_v1_9() {
1703 assert_js_no_warnings_with_gleam_version!(
1704 Range::higher_than(Version::new(1, 8, 0)),
1705 r#"
1706@external(javascript, "test.mjs", "go")
1707pub fn go() -> BitArray {
1708 let <<a:bits>> = <<>>
1709 a
1710}
1711 "#,
1712 );
1713}
1714
1715#[test]
1716fn as_module_const() {
1717 assert_js!(
1718 r#"
1719 pub const data = <<
1720 0x1,
1721 2,
1722 2:size(16),
1723 0x4:size(32),
1724 -1:32,
1725 "Gleam":utf8,
1726 4.2:float,
1727 4.2:32-float,
1728 <<0xFA>>:bits-6,
1729 -1:64,
1730 <<
1731 <<1, 2, 3>>:bits,
1732 "Gleam":utf8,
1733 1024
1734 >>:bits
1735 >>
1736 "#
1737 )
1738}
1739
1740#[test]
1741fn bit_array_literal_string_constant_is_treated_as_utf8() {
1742 assert_js!(r#"pub const a = <<"hello", " ", "world">>"#);
1743}
1744
1745#[test]
1746fn bit_array_literal_string_is_treated_as_utf8() {
1747 assert_js!(
1748 r#"
1749pub fn main() {
1750 <<"hello", " ", "world">>
1751}"#
1752 );
1753}
1754
1755#[test]
1756fn bit_array_literal_string_pattern_is_treated_as_utf8() {
1757 assert_js!(
1758 r#"
1759pub fn main() {
1760 case <<>> {
1761 <<"a", "b", _:bytes>> -> 1
1762 _ -> 2
1763 }
1764}"#
1765 );
1766}
1767
1768#[test]
1769fn with_unit() {
1770 assert_js!(
1771 r#"
1772pub fn main() {
1773 <<1:size(2)-unit(2), 2:size(3)-unit(4)>>
1774}
1775"#,
1776 );
1777}
1778
1779#[test]
1780fn dynamic_size_with_unit() {
1781 assert_js!(
1782 r#"
1783pub fn main() {
1784 let size = 3
1785 <<1:size(size)-unit(2)>>
1786}
1787"#,
1788 );
1789}
1790
1791#[test]
1792fn pattern_with_unit() {
1793 assert_js!(
1794 r#"
1795pub fn go(x) {
1796 let assert <<1:size(2)-unit(2), 2:size(3)-unit(4)>> = x
1797}
1798"#,
1799 );
1800}
1801
1802#[test]
1803fn case_pattern_with_unit() {
1804 assert_js!(
1805 r#"
1806pub fn go(x) {
1807 case x {
1808 <<1:size(2)-unit(2), 2:size(3)-unit(4)>> -> 1
1809 _ -> 2
1810 }
1811}
1812"#,
1813 );
1814}
1815
1816#[test]
1817fn dynamic_size_pattern_with_unit() {
1818 assert_js!(
1819 r#"
1820pub fn go(x) {
1821 let size = 3
1822 let assert <<1:size(size)-unit(2)>> = x
1823}
1824"#,
1825 );
1826}
1827
1828#[test]
1829fn case_dynamic_size_pattern_with_unit() {
1830 assert_js!(
1831 r#"
1832pub fn go(x) {
1833 let size = 3
1834 case x {
1835 <<1:size(size)-unit(2)>> -> 1
1836 _ -> 2
1837 }
1838}
1839"#,
1840 );
1841}
1842
1843#[test]
1844fn case_dynamic_size_float_pattern_with_unit() {
1845 assert_js!(
1846 r#"
1847pub fn go(x) {
1848 let size = 3
1849 case x {
1850 <<1.3:size(size)-unit(2)>> -> 1
1851 _ -> 2
1852 }
1853}
1854"#,
1855 );
1856}
1857
1858#[test]
1859fn case_with_remaining_bytes_after_constant_size() {
1860 assert_js!(
1861 r#"
1862pub fn go(x) {
1863 case x {
1864 <<_, _, _:bytes>> -> 1
1865 _ -> 2
1866 }
1867}
1868"#,
1869 );
1870}
1871
1872#[test]
1873fn case_with_remaining_bytes_after_variable_size() {
1874 assert_js!(
1875 r#"
1876pub fn go(x) {
1877 let n = 1
1878 case x {
1879 <<_:size(n), _, _:bytes>> -> 1
1880 _ -> 2
1881 }
1882}
1883"#,
1884 );
1885}
1886
1887#[test]
1888fn case_with_remaining_bytes_after_variable_size_2() {
1889 assert_js!(
1890 r#"
1891pub fn go(x) {
1892 let n = 1
1893 case x {
1894 <<m:size(n), _:size(m), _:bytes>> -> 1
1895 _ -> 2
1896 }
1897}
1898"#,
1899 );
1900}
1901
1902#[test]
1903fn case_is_byte_aligned() {
1904 assert_js!(
1905 r#"
1906pub fn is_byte_aligned(x) {
1907 case x {
1908 <<_:bytes>> -> True
1909 _ -> False
1910 }
1911}
1912"#,
1913 );
1914}
1915
1916#[test]
1917fn alternative_patterns_with_variable_size() {
1918 assert_js!(
1919 r#"
1920pub fn go(x) {
1921 case x {
1922 <<_, n, rest:size(n)>> |
1923 <<n, _, rest:size(n)>> -> True
1924 _ -> False
1925 }
1926}
1927"#,
1928 );
1929}
1930
1931#[test]
1932fn variable_sized_segment() {
1933 assert_js!(
1934 r#"
1935pub fn go(x) {
1936 case x {
1937 <<n, rest:size(n)>> -> 1
1938 _ -> 2
1939 }
1940}
1941"#
1942 )
1943}
1944
1945#[test]
1946fn segments_shadowing_each_other() {
1947 assert_js!(
1948 r#"
1949pub fn go(x) {
1950 let n = 1
1951 case x {
1952 <<n, rest:size(n)>> -> 1
1953 _ -> 2
1954 }
1955}
1956"#
1957 )
1958}
1959
1960#[test]
1961fn negative_size_pattern() {
1962 assert_js!(
1963 r#"
1964pub fn go(x) {
1965 let n = -10
1966 case x {
1967 <<int:size(n)>> -> int
1968 _ -> 2
1969 }
1970}
1971"#
1972 )
1973}
1974
1975#[test]
1976fn negative_size_pattern_2() {
1977 assert_js!(
1978 r#"
1979pub fn go(x) {
1980 case x {
1981 <<n:signed, int:size(n)>> -> int
1982 _ -> 2
1983 }
1984}
1985"#
1986 )
1987}
1988
1989// https://github.com/gleam-lang/gleam/issues/3375
1990#[test]
1991fn bit_array_assignment_int() {
1992 assert_js!(
1993 "
1994pub fn main() {
1995 let assert <<1 as a>> = <<1>>
1996 a
1997}
1998"
1999 );
2000}
2001
2002#[test]
2003fn case_bit_array_assignment_int() {
2004 assert_js!(
2005 "
2006pub fn go(x) {
2007 case x {
2008 <<1 as n>>
2009 | <<2 as n, _:bytes>> -> n
2010 _ -> 1
2011 }
2012}
2013"
2014 );
2015}
2016
2017// https://github.com/gleam-lang/gleam/issues/3375
2018#[test]
2019fn bit_array_assignment_float() {
2020 assert_js!(
2021 "
2022pub fn main() {
2023 let assert <<3.14 as pi:float>> = <<3.14>>
2024 pi
2025}
2026"
2027 );
2028}
2029
2030#[test]
2031fn case_bit_array_assignment_float() {
2032 assert_js!(
2033 "
2034pub fn go(x) {
2035 case x {
2036 <<3.14 as pi:float>>
2037 | <<1.1 as pi:float, _:bytes>> -> pi
2038 _ -> 1.1
2039 }
2040}
2041"
2042 );
2043}
2044
2045// https://github.com/gleam-lang/gleam/issues/3375
2046#[test]
2047fn bit_array_assignment_string() {
2048 assert_js!(
2049 r#"
2050pub fn main() {
2051 let assert <<"Hello, world!" as message:utf8>> = <<"Hello, world!">>
2052 message
2053}
2054"#
2055 );
2056}
2057
2058#[test]
2059fn case_bit_array_assignment_string() {
2060 assert_js!(
2061 r#"
2062pub fn go(x) {
2063 case x {
2064 <<"Hello" as message>>
2065 | <<"Jak" as message, _:bytes>> -> message
2066 _ -> "wibble"
2067 }
2068}
2069"#
2070 );
2071}
2072
2073// https://github.com/gleam-lang/gleam/issues/3375
2074#[test]
2075fn bit_array_assignment_discard() {
2076 assert_js!(
2077 r#"
2078pub fn main() {
2079 let assert <<_ as number>> = <<10>>
2080 number
2081}
2082"#
2083 );
2084}
2085
2086#[test]
2087fn case_bit_array_assignment_discard() {
2088 assert_js!(
2089 r#"
2090pub fn go(x) {
2091 case x {
2092 <<_ as n>>
2093 | <<_ as n, _:bytes>> -> n
2094 _ -> 1
2095 }
2096}
2097"#
2098 );
2099}
2100
2101#[test]
2102fn utf16() {
2103 assert_js!(
2104 r#"
2105pub fn main() {
2106 <<"Hello, world!":utf16>>
2107}
2108"#
2109 );
2110}
2111
2112#[test]
2113fn utf16_codepoint() {
2114 assert_js!(
2115 r#"
2116fn codepoint() -> UtfCodepoint { todo }
2117
2118pub fn main() {
2119 let my_codepoint = codepoint()
2120 <<my_codepoint:utf16_codepoint>>
2121}
2122"#
2123 );
2124}
2125
2126#[test]
2127fn utf32() {
2128 assert_js!(
2129 r#"
2130pub fn main() {
2131 <<"Hello, world!":utf32>>
2132}
2133"#
2134 );
2135}
2136
2137#[test]
2138fn utf32_codepoint() {
2139 assert_js!(
2140 r#"
2141fn codepoint() -> UtfCodepoint { todo }
2142
2143pub fn main() {
2144 let my_codepoint = codepoint()
2145 <<my_codepoint:utf32_codepoint>>
2146}
2147"#
2148 );
2149}
2150
2151#[test]
2152fn const_utf16() {
2153 assert_js!(
2154 r#"
2155pub const message = <<"Hello, world!":utf16>>
2156"#
2157 );
2158}
2159
2160#[test]
2161fn const_utf32() {
2162 assert_js!(
2163 r#"
2164pub const message = <<"Hello, world!":utf32>>
2165"#
2166 );
2167}
2168
2169#[test]
2170fn pattern_match_utf16() {
2171 assert_js!(
2172 r#"
2173pub fn go(x) {
2174 let assert <<"Hello":utf16, _rest:bytes>> = x
2175}
2176"#
2177 );
2178}
2179
2180#[test]
2181fn pattern_match_utf32() {
2182 assert_js!(
2183 r#"
2184pub fn go(x) {
2185 let assert <<"Hello":utf32, _rest:bytes>> = x
2186}
2187"#
2188 );
2189}
2190
2191#[test]
2192fn utf16_little_endian() {
2193 assert_js!(
2194 r#"
2195pub fn main() {
2196 <<"Hello, world!":utf16-little>>
2197}
2198"#
2199 );
2200}
2201
2202#[test]
2203fn utf32_little_endian() {
2204 assert_js!(
2205 r#"
2206pub fn main() {
2207 <<"Hello, world!":utf32-little>>
2208}
2209"#
2210 );
2211}
2212
2213#[test]
2214fn pattern_match_utf16_little_endian() {
2215 assert_js!(
2216 r#"
2217pub fn go(x) {
2218 let assert <<"Hello":utf16-little, _rest:bytes>> = x
2219}
2220"#
2221 );
2222}
2223
2224#[test]
2225fn pattern_match_utf32_little_endian() {
2226 assert_js!(
2227 r#"
2228pub fn go(x) {
2229 let assert <<"Hello":utf32-little, _rest:bytes>> = x
2230}
2231"#
2232 );
2233}
2234
2235// https://github.com/gleam-lang/gleam/issues/4630
2236#[test]
2237fn tuple_bit_array() {
2238 assert_js!(
2239 "
2240pub fn go(x) {
2241 let assert #(<<>>) = x
2242}
2243"
2244 );
2245}
2246
2247// https://github.com/gleam-lang/gleam/issues/4630
2248#[test]
2249fn tuple_bit_array_case() {
2250 assert_js!(
2251 "
2252pub fn go(x) {
2253 case x {
2254 #(<<>>) -> 1
2255 _ -> 2
2256 }
2257}
2258"
2259 );
2260}
2261
2262#[test]
2263fn tuple_multiple_bit_arrays() {
2264 assert_js!(
2265 "
2266pub fn go(x) {
2267 let assert #(<<>>, <<1>>, <<2, 3>>) = x
2268}
2269"
2270 );
2271}
2272
2273#[test]
2274fn tuple_multiple_bit_arrays_case() {
2275 assert_js!(
2276 "
2277pub fn go(x) {
2278 case x {
2279 #(<<>>, <<1>>, <<2, 3>>) -> True
2280 _ -> False
2281 }
2282}
2283"
2284 );
2285}
2286
2287// https://github.com/gleam-lang/gleam/issues/4637
2288#[test]
2289fn pattern_matching_on_32_float_plus_infinity_still_reachable() {
2290 assert_js!(
2291 r#"
2292pub fn go(x) {
2293 case x {
2294 <<_:32-float>> -> "Float"
2295 <<0x7f800000:32>> -> "+Infinity"
2296 _ -> "Other"
2297 }
2298}
2299"#
2300 );
2301}
2302
2303#[test]
2304fn pattern_matching_on_32_float_plus_infinity_still_reachable_2() {
2305 assert_js!(
2306 r#"
2307pub fn go(x) {
2308 case x {
2309 <<_:32-float>> -> "Float"
2310 <<0x7f80:16, 0x0000:16>> -> "+Infinity"
2311 _ -> "Other"
2312 }
2313}
2314"#
2315 );
2316}
2317
2318#[test]
2319fn pattern_matching_on_32_float_minus_infinity_still_reachable() {
2320 assert_js!(
2321 r#"
2322pub fn go(x) {
2323 case x {
2324 <<_:32-float>> -> "Float"
2325 <<0xff800000:32>> -> "-Infinity"
2326 _ -> "Other"
2327 }
2328}
2329"#
2330 );
2331}
2332
2333#[test]
2334fn pattern_matching_on_32_float_minus_infinity_still_reachable_2() {
2335 assert_js!(
2336 r#"
2337pub fn go(x) {
2338 case x {
2339 <<_:32-float>> -> "Float"
2340 <<0xff80:16, 0x0000:16>> -> "-Infinity"
2341 _ -> "Other"
2342 }
2343}
2344"#
2345 );
2346}
2347
2348#[test]
2349fn pattern_matching_on_32_float_nan_still_reachable() {
2350 assert_js!(
2351 r#"
2352pub fn go(x) {
2353 case x {
2354 <<_:32-float>> -> "Float"
2355 <<0x7fc00000:32>> -> "NaN"
2356 _ -> "Other"
2357 }
2358}
2359"#
2360 );
2361}
2362
2363#[test]
2364fn pattern_matching_on_32_float_nan_still_reachable_2() {
2365 assert_js!(
2366 r#"
2367pub fn go(x) {
2368 case x {
2369 <<_:32-float>> -> "Float"
2370 <<0x7fc0:16, 0x0000:16>> -> "NaN"
2371 _ -> "Other"
2372 }
2373}
2374"#
2375 );
2376}
2377
2378#[test]
2379fn pattern_matching_on_64_float_plus_infinity_still_reachable() {
2380 assert_js!(
2381 r#"
2382pub fn go(x) {
2383 case x {
2384 <<_:64-float>> -> "Float"
2385 <<0x7ff0000000000000:64>> -> "+Infinity"
2386 _ -> "Other"
2387 }
2388}
2389"#
2390 );
2391}
2392
2393#[test]
2394fn pattern_matching_on_64_float_plus_infinity_still_reachable_2() {
2395 assert_js!(
2396 r#"
2397pub fn go(x) {
2398 case x {
2399 <<_:64-float>> -> "Float"
2400 <<0x7ff00000:32, 0x00000000:32>> -> "+Infinity"
2401 _ -> "Other"
2402 }
2403}
2404"#
2405 );
2406}
2407
2408#[test]
2409fn pattern_matching_on_64_float_minus_infinity_still_reachable() {
2410 assert_js!(
2411 r#"
2412pub fn go(x) {
2413 case x {
2414 <<_:64-float>> -> "Float"
2415 <<0xfff0000000000000:64>> -> "-Infinity"
2416 _ -> "Other"
2417 }
2418}
2419"#
2420 );
2421}
2422
2423#[test]
2424fn pattern_matching_on_64_float_minus_infinity_still_reachable_2() {
2425 assert_js!(
2426 r#"
2427pub fn go(x) {
2428 case x {
2429 <<_:64-float>> -> "Float"
2430 <<0xfff00000:32, 0x00000000:32>> -> "-Infinity"
2431 _ -> "Other"
2432 }
2433}
2434"#
2435 );
2436}
2437
2438#[test]
2439fn pattern_matching_on_64_float_nan_still_reachable() {
2440 assert_js!(
2441 r#"
2442pub fn go(x) {
2443 case x {
2444 <<_:64-float>> -> "Float"
2445 <<0x7ff8000000000000:64>> -> "NaN"
2446 _ -> "Other"
2447 }
2448}
2449"#
2450 );
2451}
2452
2453#[test]
2454fn pattern_matching_on_64_float_nan_still_reachable_2() {
2455 assert_js!(
2456 r#"
2457pub fn go(x) {
2458 case x {
2459 <<_:64-float>> -> "Float"
2460 <<0x7ff80000:32, 0x00000000:32>> -> "NaN"
2461 _ -> "Other"
2462 }
2463}
2464"#
2465 );
2466}
2467
2468#[test]
2469fn pattern_matching_on_64_float_int_is_still_reachable() {
2470 assert_js!(
2471 r#"
2472pub fn go(x) {
2473 case x {
2474 <<_:64-float>> -> "Float"
2475 <<_:64-int>> -> "Int"
2476 _ -> "Other"
2477 }
2478}
2479"#
2480 );
2481}
2482
2483#[test]
2484fn pattern_matching_on_64_float_float_is_unreachable() {
2485 assert_js!(
2486 r#"
2487pub fn go(x) {
2488 case x {
2489 <<_:64-float>> -> "Float"
2490 <<_:64-float>> -> "unreachable"
2491 _ -> "Other"
2492 }
2493}
2494"#
2495 );
2496}
2497
2498#[test]
2499fn unit_with_bits_option() {
2500 assert_js!(
2501 "
2502pub fn go(x) {
2503 <<x:bits-size(4)-unit(8)>>
2504}
2505"
2506 );
2507}
2508
2509#[test]
2510fn unit_with_bits_option_constant() {
2511 assert_js!(
2512 "
2513pub const bits = <<1, 2, 3>>
2514pub const more_bits = <<bits:bits-size(3)-unit(8)>>
2515"
2516 );
2517}
2518
2519#[test]
2520fn operator_in_size_for_bit_array_segment() {
2521 assert_js!(
2522 "
2523pub fn go(x) {
2524 <<x:bits-size(4 + 1)>>
2525}
2526"
2527 );
2528}
2529
2530// https://github.com/gleam-lang/gleam/issues/4712
2531#[test]
2532fn multiple_variable_size_segments() {
2533 assert_js!(
2534 "
2535pub fn main() {
2536 let assert <<a, b:size(a), c:size(b)>> = <<1, 2, 3, 4>>
2537 a + b + c
2538}
2539"
2540 );
2541}
2542
2543#[test]
2544fn utf16_codepoint_little_endian() {
2545 assert_js!(
2546 "
2547pub fn go(codepoint) {
2548 <<codepoint:utf16_codepoint-little>>
2549}
2550"
2551 );
2552}
2553
2554#[test]
2555fn utf32_codepoint_little_endian() {
2556 assert_js!(
2557 "
2558pub fn go(codepoint) {
2559 <<codepoint:utf32_codepoint-little>>
2560}
2561"
2562 );
2563}
2564
2565#[test]
2566fn operator_in_pattern_size() {
2567 assert_js!(
2568 "
2569pub fn main() {
2570 let assert <<len, payload:size(len * 8)>> = <<>>
2571}
2572"
2573 );
2574}
2575
2576#[test]
2577fn operator_in_pattern_size2() {
2578 assert_js!(
2579 "
2580pub fn main() {
2581 let assert <<len, payload:size(len / 8 - 1)>> = <<>>
2582}
2583"
2584 );
2585}
2586
2587#[test]
2588fn operator_in_pattern_size3() {
2589 assert_js!(
2590 "
2591pub fn main() {
2592 let additional = 10
2593 let assert <<len, payload:size(len + additional * 8)>> = <<>>
2594}
2595"
2596 );
2597}
2598
2599#[test]
2600fn block_in_pattern_size() {
2601 assert_js!(
2602 "
2603pub fn main() {
2604 let assert <<len, payload:size({ len - 1 } * 8)>> = <<>>
2605}
2606"
2607 );
2608}
2609
2610#[test]
2611fn non_byte_aligned_size_calculation() {
2612 assert_js!(
2613 "
2614pub fn main() {
2615 case <<>> {
2616 <<a:1, b:3, c:size(b - 2)>> -> c + b
2617 _ -> 1
2618 }
2619}
2620"
2621 );
2622}
2623
2624#[test]
2625fn pattern_match_on_negative_size_calculation() {
2626 assert_js!(
2627 "
2628pub fn main() {
2629 let assert <<a, b:size(a - 100000), c:size(b)>> = <<1, 2, 3, 4, 5>>
2630}
2631"
2632 );
2633}
2634
2635#[test]
2636fn pattern_match_unknown_size_and_literal_string() {
2637 assert_js!(
2638 r#"
2639pub fn go(x, n) {
2640 case x {
2641 <<_:size(n), "\r\n">> -> 1
2642 _ -> 2
2643 }
2644}
2645"#
2646 );
2647}