1pub use squeeze_i8::SqueezeTo_i8;
2pub use squeeze_i16::SqueezeTo_i16;
3pub use squeeze_i32::SqueezeTo_i32;
4pub use squeeze_i64::SqueezeTo_i64;
5pub use squeeze_i128::SqueezeTo_i128;
6pub use squeeze_isize::SqueezeTo_isize;
7
8pub use squeeze_u8::SqueezeTo_u8;
9pub use squeeze_u16::SqueezeTo_u16;
10pub use squeeze_u32::SqueezeTo_u32;
11pub use squeeze_u64::SqueezeTo_u64;
12pub use squeeze_u128::SqueezeTo_u128;
13pub use squeeze_usize::SqueezeTo_usize;
14
15mod squeeze_i8;
16mod squeeze_i16;
17mod squeeze_i32;
18mod squeeze_i64;
19mod squeeze_i128;
20mod squeeze_isize;
21
22mod squeeze_u8;
23mod squeeze_u16;
24mod squeeze_u32;
25mod squeeze_u64;
26mod squeeze_u128;
27mod squeeze_usize;
28
29pub trait SqueezeTo<T> {
30 fn squeeze_to(&self) -> T;
31}
32
33mod gen_i8 {
34 use super::*;
35
36 impl<T> SqueezeTo<i8> for T where T: SqueezeTo_i8 {
37 #[inline(always)]
38 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
39 fn squeeze_to(&self) -> i8 {
40 return self.squeeze_to_i8();
41 }
42 }
43
44 #[cfg(test)]
45 mod tests {
46 use super::*;
47
48 #[test]
49 fn test_squeeze_to_i8() {
50 inner(i8::MAX, i8::MAX);
51 inner(i8::MIN, i8::MIN);
52 inner(5_i8, 5);
53 inner(-5_i8, -5);
54
55 inner(i16::MAX, i8::MAX);
56 inner(i16::MIN, i8::MIN);
57 inner(5_i16, 5);
58 inner(-5_i16, -5);
59
60 inner(i32::MAX, i8::MAX);
61 inner(i32::MIN, i8::MIN);
62 inner(5_i32, 5);
63 inner(-5_i32, -5);
64
65 inner(i64::MAX, i8::MAX);
66 inner(i64::MIN, i8::MIN);
67 inner(5_i64, 5);
68 inner(-5_i64, -5);
69
70 inner(i128::MAX, i8::MAX);
71 inner(i128::MIN, i8::MIN);
72 inner(5_i128, 5);
73 inner(-5_i128, -5);
74
75 inner(isize::MAX, i8::MAX);
76 inner(isize::MIN, i8::MIN);
77 inner(5_isize, 5);
78 inner(-5_isize, -5);
79
80 inner(u8::MAX, i8::MAX);
81 inner(0_u8, 0);
82 inner(5_u8, 5);
83
84 inner(u16::MAX, i8::MAX);
85 inner(0_u16, 0);
86 inner(5_u16, 5);
87
88 inner(u32::MAX, i8::MAX);
89 inner(0_u32, 0);
90 inner(5_u32, 5);
91
92 inner(u64::MAX, i8::MAX);
93 inner(0_u64, 0);
94 inner(5_u64, 5);
95
96 inner(u128::MAX, i8::MAX);
97 inner(0_u128, 0);
98 inner(5_u128, 5);
99
100 inner(usize::MAX, i8::MAX);
101 inner(0_usize, 0);
102 inner(5_usize, 5);
103 }
104
105 fn inner(input: impl SqueezeTo_i8, expect: i8) {
106 assert_eq!(input.squeeze_to(), expect);
107 }
108 }
109}
110
111mod gen_i16 {
112 use super::*;
113 impl<T> SqueezeTo<i16> for T where T: SqueezeTo_i16 {
114 #[inline(always)]
115 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
116 fn squeeze_to(&self) -> i16 {
117 return self.squeeze_to_i16();
118 }
119 }
120
121 #[cfg(test)]
122 mod tests {
123 use super::*;
124
125 #[test]
126 fn test_squeeze_to_i16() {
127 inner(i8::MAX, i8::MAX as i16);
128 inner(i8::MIN, i8::MIN as i16);
129 inner(5_i8, 5);
130 inner(-5_i8, -5);
131
132 inner(i16::MAX, i16::MAX);
133 inner(i16::MIN, i16::MIN);
134 inner(5_i16, 5);
135 inner(-5_i16, -5);
136
137 inner(i32::MAX, i16::MAX);
138 inner(i32::MIN, i16::MIN);
139 inner(5_i32, 5);
140 inner(-5_i32, -5);
141
142 inner(i64::MAX, i16::MAX);
143 inner(i64::MIN, i16::MIN);
144 inner(5_i64, 5);
145 inner(-5_i64, -5);
146
147 inner(i128::MAX, i16::MAX);
148 inner(i128::MIN, i16::MIN);
149 inner(5_i128, 5);
150 inner(-5_i128, -5);
151
152 inner(isize::MAX, i16::MAX);
153 inner(isize::MIN, i16::MIN);
154 inner(5_isize, 5);
155 inner(-5_isize, -5);
156
157 inner(u8::MAX, u8::MAX as i16);
158 inner(0_u8, 0);
159 inner(5_u8, 5);
160
161 inner(u16::MAX, i16::MAX);
162 inner(0_u16, 0);
163 inner(5_u16, 5);
164
165 inner(u32::MAX, i16::MAX);
166 inner(0_u32, 0);
167 inner(5_u32, 5);
168
169 inner(u64::MAX, i16::MAX);
170 inner(0_u64, 0);
171 inner(5_u64, 5);
172
173 inner(u128::MAX, i16::MAX);
174 inner(0_u128, 0);
175 inner(5_u128, 5);
176
177 inner(usize::MAX, i16::MAX);
178 inner(0_usize, 0);
179 inner(5_usize, 5);
180 }
181
182 fn inner(input: impl SqueezeTo_i16, expect: i16) {
183 assert_eq!(input.squeeze_to(), expect);
184 }
185 }
186}
187
188mod gen_i32 {
189 use super::*;
190 impl<T> SqueezeTo<i32> for T where T: SqueezeTo_i32 {
191 #[inline(always)]
192 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
193 fn squeeze_to(&self) -> i32 {
194 return self.squeeze_to_i32();
195 }
196 }
197
198 #[cfg(test)]
199 mod tests {
200 use super::*;
201
202 #[test]
203 fn test_squeeze_to_i32() {
204 inner(i8::MAX, i8::MAX as i32);
205 inner(i8::MIN, i8::MIN as i32);
206 inner(5_i8, 5);
207 inner(-5_i8, -5);
208
209 inner(i16::MAX, i16::MAX as i32);
210 inner(i16::MIN, i16::MIN as i32);
211 inner(5_i16, 5);
212 inner(-5_i16, -5);
213
214 inner(i32::MAX, i32::MAX);
215 inner(i32::MIN, i32::MIN);
216 inner(5_i32, 5);
217 inner(-5_i32, -5);
218
219 inner(i64::MAX, i32::MAX);
220 inner(i64::MIN, i32::MIN);
221 inner(5_i64, 5);
222 inner(-5_i64, -5);
223
224 inner(i128::MAX, i32::MAX);
225 inner(i128::MIN, i32::MIN);
226 inner(5_i128, 5);
227 inner(-5_i128, -5);
228
229 inner(isize::MAX, i32::MAX);
230 inner(isize::MIN, i32::MIN);
231 inner(5_isize, 5);
232 inner(-5_isize, -5);
233
234 inner(u8::MAX, u8::MAX as i32);
235 inner(0_u8, 0);
236 inner(5_u8, 5);
237
238 inner(u16::MAX, u16::MAX as i32);
239 inner(0_u16, 0);
240 inner(5_u16, 5);
241
242 inner(u32::MAX, i32::MAX);
243 inner(0_u32, 0);
244 inner(5_u32, 5);
245
246 inner(u64::MAX, i32::MAX);
247 inner(0_u64, 0);
248 inner(5_u64, 5);
249
250 inner(u128::MAX, i32::MAX);
251 inner(0_u128, 0);
252 inner(5_u128, 5);
253
254 inner(usize::MAX, i32::MAX);
255 inner(0_usize, 0);
256 inner(5_usize, 5);
257 }
258
259 fn inner(input: impl SqueezeTo_i32, expect: i32) {
260 assert_eq!(input.squeeze_to(), expect);
261 }
262 }
263}
264
265mod gen_i64 {
266 use super::*;
267 impl<T> SqueezeTo<i64> for T where T: SqueezeTo_i64 {
268 #[inline(always)]
269 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
270 fn squeeze_to(&self) -> i64 {
271 return self.squeeze_to_i64();
272 }
273 }
274
275 #[cfg(test)]
276 mod tests {
277 use super::*;
278
279 #[test]
280 fn test_squeeze_to_i64() {
281 inner(i8::MAX, i8::MAX as i64);
282 inner(i8::MIN, i8::MIN as i64);
283 inner(5_i8, 5);
284 inner(-5_i8, -5);
285
286 inner(i16::MAX, i16::MAX as i64);
287 inner(i16::MIN, i16::MIN as i64);
288 inner(5_i16, 5);
289 inner(-5_i16, -5);
290
291 inner(i32::MAX, i32::MAX as i64);
292 inner(i32::MIN, i32::MIN as i64);
293 inner(5_i32, 5);
294 inner(-5_i32, -5);
295
296 inner(i64::MAX, i64::MAX);
297 inner(i64::MIN, i64::MIN);
298 inner(5_i64, 5);
299 inner(-5_i64, -5);
300
301 inner(i128::MAX, i64::MAX);
302 inner(i128::MIN, i64::MIN);
303 inner(5_i128, 5);
304 inner(-5_i128, -5);
305
306 #[cfg(target_pointer_width = "32")]
307 {
308 inner(isize::MAX, isize::MAX as i64);
309 inner(isize::MIN, isize::MIN as i64);
310 inner(5_isize, 5);
311 inner(-5_isize, -5);
312 }
313
314 #[cfg(target_pointer_width = "64")]
315 {
316 inner(isize::MAX, i64::MAX);
317 inner(isize::MIN, i64::MIN);
318 inner(5_isize, 5);
319 inner(-5_isize, -5);
320 }
321
322 inner(u8::MAX, u8::MAX as i64);
323 inner(0_u8, 0);
324 inner(5_u8, 5);
325
326 inner(u16::MAX, u16::MAX as i64);
327 inner(0_u16, 0);
328 inner(5_u16, 5);
329
330 inner(u32::MAX, u32::MAX as i64);
331 inner(0_u32, 0);
332 inner(5_u32, 5);
333
334 inner(u64::MAX, i64::MAX);
335 inner(0_u64, 0);
336 inner(5_u64, 5);
337
338 inner(u128::MAX, i64::MAX);
339 inner(0_u128, 0);
340 inner(5_u128, 5);
341
342 #[cfg(target_pointer_width = "32")]
343 {
344 inner(usize::MAX, usize::MAX as i64);
345 inner(0_usize, 0);
346 inner(5_usize, 5);
347 }
348
349 #[cfg(target_pointer_width = "64")]
350 {
351 inner(usize::MAX, i64::MAX);
352 inner(0_usize, 0);
353 inner(5_usize, 5);
354 }
355 }
356
357 fn inner(input: impl SqueezeTo_i64, expect: i64) {
358 assert_eq!(input.squeeze_to(), expect);
359 }
360 }
361}
362
363mod gen_i128 {
364 use super::*;
365 impl<T> SqueezeTo<i128> for T where T: SqueezeTo_i128 {
366 #[inline(always)]
367 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
368 fn squeeze_to(&self) -> i128 {
369 return self.squeeze_to_i128();
370 }
371 }
372
373 #[cfg(test)]
374 mod tests {
375 use super::*;
376
377 #[test]
378 fn test_squeeze_to_i128() {
379 inner(i8::MAX, i8::MAX as i128);
380 inner(i8::MIN, i8::MIN as i128);
381 inner(5_i8, 5);
382 inner(-5_i8, -5);
383
384 inner(i16::MAX, i16::MAX as i128);
385 inner(i16::MIN, i16::MIN as i128);
386 inner(5_i16, 5);
387 inner(-5_i16, -5);
388
389 inner(i32::MAX, i32::MAX as i128);
390 inner(i32::MIN, i32::MIN as i128);
391 inner(5_i32, 5);
392 inner(-5_i32, -5);
393
394 inner(i64::MAX, i64::MAX as i128);
395 inner(i64::MIN, i64::MIN as i128);
396 inner(5_i64, 5);
397 inner(-5_i64, -5);
398
399 inner(i128::MAX, i128::MAX);
400 inner(i128::MIN, i128::MIN);
401 inner(5_i128, 5);
402 inner(-5_i128, -5);
403
404 inner(isize::MAX, isize::MAX as i128);
405 inner(isize::MIN, isize::MIN as i128);
406 inner(5_isize, 5);
407 inner(-5_isize, -5);
408
409 inner(u8::MAX, u8::MAX as i128);
410 inner(0_u8, 0);
411 inner(5_u8, 5);
412
413 inner(u16::MAX, u16::MAX as i128);
414 inner(0_u16, 0);
415 inner(5_u16, 5);
416
417 inner(u32::MAX, u32::MAX as i128);
418 inner(0_u32, 0);
419 inner(5_u32, 5);
420
421 inner(u64::MAX, u64::MAX as i128);
422 inner(0_u64, 0);
423 inner(5_u64, 5);
424
425 inner(u128::MAX, i128::MAX);
426 inner(0_u128, 0);
427 inner(5_u128, 5);
428
429 inner(usize::MAX, usize::MAX as i128);
430 inner(0_usize, 0);
431 inner(5_usize, 5);
432 }
433
434 fn inner(input: impl SqueezeTo_i128, expect: i128) {
435 assert_eq!(input.squeeze_to(), expect);
436 }
437 }
438}
439
440mod gen_isize {
441 use super::*;
442 impl<T> SqueezeTo<isize> for T where T: SqueezeTo_isize {
443 #[inline(always)]
444 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
445 fn squeeze_to(&self) -> isize {
446 return self.squeeze_to_isize();
447 }
448 }
449
450 #[cfg(test)]
451 mod tests {
452 use super::*;
453
454 #[test]
455 fn test_squeeze_to_isize() {
456 inner(i8::MAX, i8::MAX as isize);
457 inner(i8::MIN, i8::MIN as isize);
458 inner(5_i8, 5);
459 inner(-5_i8, -5);
460
461 inner(i16::MAX, i16::MAX as isize);
462 inner(i16::MIN, i16::MIN as isize);
463 inner(5_i16, 5);
464 inner(-5_i16, -5);
465
466 inner(i32::MAX, i32::MAX as isize);
467 inner(i32::MIN, i32::MIN as isize);
468 inner(5_i32, 5);
469 inner(-5_i32, -5);
470
471 #[cfg(target_pointer_width = "32")]
472 {
473 inner(i64::MAX, isize::MAX);
474 inner(i64::MIN, isize::MIN);
475 inner(5_i64, 5);
476 inner(-5_i64, -5);
477 }
478
479 #[cfg(target_pointer_width = "64")]
480 {
481 inner(i64::MAX, i64::MAX as isize);
482 inner(i64::MIN, i64::MIN as isize);
483 inner(5_i64, 5);
484 inner(-5_i64, -5);
485 }
486
487 inner(i128::MAX, isize::MAX);
488 inner(i128::MIN, isize::MIN);
489 inner(5_i128, 5);
490 inner(-5_i128, -5);
491
492 inner(isize::MAX, isize::MAX);
493 inner(isize::MIN, isize::MIN);
494 inner(5_isize, 5);
495 inner(-5_isize, -5);
496
497 inner(u8::MAX, u8::MAX as isize);
498 inner(0_u8, 0);
499 inner(5_u8, 5);
500
501 inner(u16::MAX, u16::MAX as isize);
502 inner(0_u16, 0);
503 inner(5_u16, 5);
504
505 #[cfg(target_pointer_width = "32")]
506 {
507 inner(u32::MAX, isize::MAX);
508 inner(0_u32, 0);
509 inner(5_u32, 5);
510 }
511
512 #[cfg(target_pointer_width = "64")]
513 {
514 inner(u32::MAX, u32::MAX as isize);
515 inner(0_u32, 0);
516 inner(5_u32, 5);
517 }
518
519 inner(u64::MAX, isize::MAX);
520 inner(0_u64, 0);
521 inner(5_u64, 5);
522
523 inner(u128::MAX, isize::MAX);
524 inner(0_u128, 0);
525 inner(5_u128, 5);
526
527 inner(usize::MAX, isize::MAX);
528 inner(0_usize, 0);
529 inner(5_usize, 5);
530 }
531
532 fn inner(input: impl SqueezeTo_isize, expect: isize) {
533 assert_eq!(input.squeeze_to(), expect);
534 }
535 }
536}
537
538mod gen_u8 {
539 use super::*;
540 impl<T> SqueezeTo<u8> for T where T: SqueezeTo_u8 {
541 #[inline(always)]
542 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
543 fn squeeze_to(&self) -> u8 {
544 return self.squeeze_to_u8();
545 }
546 }
547
548 #[cfg(test)]
549 mod tests {
550 use super::*;
551
552 #[test]
553 fn test_squeeze_to_u8() {
554 inner(i8::MAX, i8::MAX as u8);
555 inner(i8::MIN, 0);
556 inner(5_i8, 5);
557 inner(-5_i8, 0);
558
559 inner(i16::MAX, u8::MAX);
560 inner(i16::MIN, 0);
561 inner(5_i16, 5);
562 inner(-5_i16, 0);
563
564 inner(i32::MAX, u8::MAX);
565 inner(i32::MIN, 0);
566 inner(5_i32, 5);
567 inner(-5_i32, 0);
568
569 inner(i64::MAX, u8::MAX);
570 inner(i64::MIN, 0);
571 inner(5_i64, 5);
572 inner(-5_i64, 0);
573
574 inner(i128::MAX, u8::MAX);
575 inner(i128::MIN, 0);
576 inner(5_i128, 5);
577 inner(-5_i128, 0);
578
579 inner(isize::MAX, u8::MAX);
580 inner(isize::MIN, 0);
581 inner(5_isize, 5);
582 inner(-5_isize, 0);
583
584 inner(u8::MAX, u8::MAX);
585 inner(0_u8, 0);
586 inner(5_u8, 5);
587
588 inner(u16::MAX, u8::MAX);
589 inner(0_u16, 0);
590 inner(5_u16, 5);
591
592 inner(u32::MAX, u8::MAX);
593 inner(0_u32, 0);
594 inner(5_u32, 5);
595
596 inner(u64::MAX, u8::MAX);
597 inner(0_u64, 0);
598 inner(5_u64, 5);
599
600 inner(u128::MAX, u8::MAX);
601 inner(0_u128, 0);
602 inner(5_u128, 5);
603
604 inner(usize::MAX, u8::MAX);
605 inner(0_usize, 0);
606 inner(5_usize, 5);
607 }
608
609 fn inner(input: impl SqueezeTo_u8, expect: u8) {
610 assert_eq!(input.squeeze_to(), expect);
611 }
612 }
613}
614
615mod gen_u16 {
616 use super::*;
617 impl<T> SqueezeTo<u16> for T where T: SqueezeTo_u16 {
618 #[inline(always)]
619 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
620 fn squeeze_to(&self) -> u16 {
621 return self.squeeze_to_u16();
622 }
623 }
624
625 #[cfg(test)]
626 mod tests {
627 use super::*;
628
629 #[test]
630 fn test_squeeze_to_u16() {
631 inner(i8::MAX, i8::MAX as u16);
632 inner(i8::MIN, 0);
633 inner(5_i8, 5);
634 inner(-5_i8, 0);
635
636 inner(i16::MAX, i16::MAX as u16);
637 inner(i16::MIN, 0);
638 inner(5_i16, 5);
639 inner(-5_i16, 0);
640
641 inner(i32::MAX, u16::MAX);
642 inner(i32::MIN, 0);
643 inner(5_i32, 5);
644 inner(-5_i32, 0);
645
646 inner(i64::MAX, u16::MAX);
647 inner(i64::MIN, 0);
648 inner(5_i64, 5);
649 inner(-5_i64, 0);
650
651 inner(i128::MAX, u16::MAX);
652 inner(i128::MIN, 0);
653 inner(5_i128, 5);
654 inner(-5_i128, 0);
655
656 inner(isize::MAX, u16::MAX);
657 inner(isize::MIN, 0);
658 inner(5_isize, 5);
659 inner(-5_isize, 0);
660
661 inner(u8::MAX, u8::MAX as u16);
662 inner(0_u8, 0);
663 inner(5_u8, 5);
664
665 inner(u16::MAX, u16::MAX);
666 inner(0_u16, 0);
667 inner(5_u16, 5);
668
669 inner(u32::MAX, u16::MAX);
670 inner(0_u32, 0);
671 inner(5_u32, 5);
672
673 inner(u64::MAX, u16::MAX);
674 inner(0_u64, 0);
675 inner(5_u64, 5);
676
677 inner(u128::MAX, u16::MAX);
678 inner(0_u128, 0);
679 inner(5_u128, 5);
680
681 inner(usize::MAX, u16::MAX);
682 inner(0_usize, 0);
683 inner(5_usize, 5);
684 }
685
686 fn inner(input: impl SqueezeTo_u16, expect: u16) {
687 assert_eq!(input.squeeze_to(), expect);
688 }
689 }
690}
691
692mod gen_u32 {
693 use super::*;
694 impl<T> SqueezeTo<u32> for T where T: SqueezeTo_u32 {
695 #[inline(always)]
696 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
697 fn squeeze_to(&self) -> u32 {
698 return self.squeeze_to_u32();
699 }
700 }
701
702 #[cfg(test)]
703 mod tests {
704 use super::*;
705
706 #[test]
707 fn test_squeeze_to_u32() {
708 inner(i8::MAX, i8::MAX as u32);
709 inner(i8::MIN, 0);
710 inner(5_i8, 5);
711 inner(-5_i8, 0);
712
713 inner(i16::MAX, i16::MAX as u32);
714 inner(i16::MIN, 0);
715 inner(5_i16, 5);
716 inner(-5_i16, 0);
717
718 inner(i32::MAX, i32::MAX as u32);
719 inner(i32::MIN, 0);
720 inner(5_i32, 5);
721 inner(-5_i32, 0);
722
723 inner(i64::MAX, u32::MAX);
724 inner(i64::MIN, 0);
725 inner(5_i64, 5);
726 inner(-5_i64, 0);
727
728 inner(i128::MAX, u32::MAX);
729 inner(i128::MIN, 0);
730 inner(5_i128, 5);
731 inner(-5_i128, 0);
732
733 #[cfg(target_pointer_width = "32")]
734 {
735 inner(isize::MAX, isize::MAX as u32);
736 inner(isize::MIN, 0);
737 inner(5_isize, 5);
738 inner(-5_isize, 0);
739 }
740
741 #[cfg(target_pointer_width = "64")]
742 {
743 inner(isize::MAX, u32::MAX);
744 inner(isize::MIN, 0);
745 inner(5_isize, 5);
746 inner(-5_isize, 0);
747 }
748
749 inner(u8::MAX, u8::MAX as u32);
750 inner(0_u8, 0);
751 inner(5_u8, 5);
752
753 inner(u16::MAX, u16::MAX as u32);
754 inner(0_u16, 0);
755 inner(5_u16, 5);
756
757 inner(u32::MAX, u32::MAX);
758 inner(0_u32, 0);
759 inner(5_u32, 5);
760
761 inner(u64::MAX, u32::MAX);
762 inner(0_u64, 0);
763 inner(5_u64, 5);
764
765 inner(u128::MAX, u32::MAX);
766 inner(0_u128, 0);
767 inner(5_u128, 5);
768
769 inner(usize::MAX, u32::MAX);
770 inner(0_usize, 0);
771 inner(5_usize, 5);
772 }
773
774 fn inner(input: impl SqueezeTo_u32, expect: u32) {
775 assert_eq!(input.squeeze_to(), expect);
776 }
777 }
778}
779
780mod gen_u64 {
781 use super::*;
782 impl<T> SqueezeTo<u64> for T where T: SqueezeTo_u64 {
783 #[inline(always)]
784 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
785 fn squeeze_to(&self) -> u64 {
786 return self.squeeze_to_u64();
787 }
788 }
789
790 #[cfg(test)]
791 mod tests {
792 use super::*;
793
794 #[test]
795 fn test_squeeze_to_u64() {
796 inner(i8::MAX, i8::MAX as u64);
797 inner(i8::MIN, 0);
798 inner(5_i8, 5);
799 inner(-5_i8, 0);
800
801 inner(i16::MAX, i16::MAX as u64);
802 inner(i16::MIN, 0);
803 inner(5_i16, 5);
804 inner(-5_i16, 0);
805
806 inner(i32::MAX, i32::MAX as u64);
807 inner(i32::MIN, 0);
808 inner(5_i32, 5);
809 inner(-5_i32, 0);
810
811 inner(i64::MAX, i64::MAX as u64);
812 inner(i64::MIN, 0);
813 inner(5_i64, 5);
814 inner(-5_i64, 0);
815
816 inner(i128::MAX, u64::MAX);
817 inner(i128::MIN, 0);
818 inner(5_i128, 5);
819 inner(-5_i128, 0);
820
821 inner(isize::MAX, isize::MAX as u64);
822 inner(isize::MIN, 0);
823 inner(5_isize, 5);
824 inner(-5_isize, 0);
825
826 inner(u8::MAX, u8::MAX as u64);
827 inner(0_u8, 0);
828 inner(5_u8, 5);
829
830 inner(u16::MAX, u16::MAX as u64);
831 inner(0_u16, 0);
832 inner(5_u16, 5);
833
834 inner(u32::MAX, u32::MAX as u64);
835 inner(0_u32, 0);
836 inner(5_u32, 5);
837
838 inner(u64::MAX, u64::MAX);
839 inner(0_u64, 0);
840 inner(5_u64, 5);
841
842 inner(u128::MAX, u64::MAX);
843 inner(0_u128, 0);
844 inner(5_u128, 5);
845
846 inner(usize::MAX, usize::MAX as u64);
847 inner(0_usize, 0);
848 inner(5_usize, 5);
849 }
850
851 fn inner(input: impl SqueezeTo_u64, expect: u64) {
852 assert_eq!(input.squeeze_to(), expect);
853 }
854 }
855}
856
857mod gen_u128 {
858 use super::*;
859 impl<T> SqueezeTo<u128> for T where T: SqueezeTo_u128 {
860 #[inline(always)]
861 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
862 fn squeeze_to(&self) -> u128 {
863 return self.squeeze_to_u128();
864 }
865 }
866
867 #[cfg(test)]
868 mod tests {
869 use super::*;
870
871 #[test]
872 fn test_squeeze_to_u64() {
873 inner(i8::MAX, i8::MAX as u128);
874 inner(i8::MIN, 0);
875 inner(5_i8, 5);
876 inner(-5_i8, 0);
877
878 inner(i16::MAX, i16::MAX as u128);
879 inner(i16::MIN, 0);
880 inner(5_i16, 5);
881 inner(-5_i16, 0);
882
883 inner(i32::MAX, i32::MAX as u128);
884 inner(i32::MIN, 0);
885 inner(5_i32, 5);
886 inner(-5_i32, 0);
887
888 inner(i64::MAX, i64::MAX as u128);
889 inner(i64::MIN, 0);
890 inner(5_i64, 5);
891 inner(-5_i64, 0);
892
893 inner(i128::MAX, i128::MAX as u128);
894 inner(i128::MIN, 0);
895 inner(5_i128, 5);
896 inner(-5_i128, 0);
897
898 inner(isize::MAX, isize::MAX as u128);
899 inner(isize::MIN, 0);
900 inner(5_isize, 5);
901 inner(-5_isize, 0);
902
903 inner(u8::MAX, u8::MAX as u128);
904 inner(0_u8, 0);
905 inner(5_u8, 5);
906
907 inner(u16::MAX, u16::MAX as u128);
908 inner(0_u16, 0);
909 inner(5_u16, 5);
910
911 inner(u32::MAX, u32::MAX as u128);
912 inner(0_u32, 0);
913 inner(5_u32, 5);
914
915 inner(u64::MAX, u64::MAX as u128);
916 inner(0_u64, 0);
917 inner(5_u64, 5);
918
919 inner(u128::MAX, u128::MAX);
920 inner(0_u128, 0);
921 inner(5_u128, 5);
922
923 inner(usize::MAX, usize::MAX as u128);
924 inner(0_usize, 0);
925 inner(5_usize, 5);
926 }
927
928 fn inner(input: impl SqueezeTo_u128, expect: u128) {
929 assert_eq!(input.squeeze_to(), expect);
930 }
931 }
932}
933
934mod gen_usize {
935 use super::*;
936 impl<T> SqueezeTo<usize> for T where T: SqueezeTo_usize {
937 #[inline(always)]
938 #[cfg_attr(feature = "no_panic", no_panic::no_panic)]
939 fn squeeze_to(&self) -> usize {
940 return self.squeeze_to_usize();
941 }
942 }
943
944 #[cfg(test)]
945 mod tests {
946 use super::*;
947
948 #[test]
949 fn test_squeeze_to_usize() {
950 inner(i8::MAX, i8::MAX as usize);
951 inner(i8::MIN, 0);
952 inner(5_i8, 5);
953 inner(-5_i8, 0);
954
955 inner(i16::MAX, i16::MAX as usize);
956 inner(i16::MIN, 0);
957 inner(5_i16, 5);
958 inner(-5_i16, 0);
959
960 inner(i32::MAX, i32::MAX as usize);
961 inner(i32::MIN, 0);
962 inner(5_i32, 5);
963 inner(-5_i32, 0);
964
965 #[cfg(target_pointer_width = "32")]
966 {
967 inner(i64::MAX, usize::MAX);
968 inner(i64::MIN, 0);
969 inner(5_i64, 5);
970 inner(-5_i64, 0);
971 }
972
973 #[cfg(target_pointer_width = "64")]
974 {
975 inner(i64::MAX, i64::MAX as usize);
976 inner(i64::MIN, 0);
977 inner(5_i64, 5);
978 inner(-5_i64, 0);
979 }
980
981 inner(i128::MAX, usize::MAX);
982 inner(i128::MIN, 0);
983 inner(5_i128, 5);
984 inner(-5_i128, 0);
985
986 inner(isize::MAX, isize::MAX as usize);
987 inner(isize::MIN, 0);
988 inner(5_isize, 5);
989 inner(-5_isize, 0);
990
991 inner(u8::MAX, u8::MAX as usize);
992 inner(0_u8, 0);
993 inner(5_u8, 5);
994
995 inner(u16::MAX, u16::MAX as usize);
996 inner(0_u16, 0);
997 inner(5_u16, 5);
998
999 inner(u32::MAX, u32::MAX as usize);
1000 inner(0_u32, 0);
1001 inner(5_u32, 5);
1002
1003 #[cfg(target_pointer_width = "32")]
1004 {
1005 inner(u64::MAX, usize::MAX);
1006 inner(0_u64, 0);
1007 inner(5_u64, 5);
1008 }
1009
1010 #[cfg(target_pointer_width = "64")]
1011 {
1012 inner(u64::MAX, u64::MAX as usize);
1013 inner(0_u64, 0);
1014 inner(5_u64, 5);
1015 }
1016
1017 inner(u128::MAX, usize::MAX);
1018 inner(0_u128, 0);
1019 inner(5_u128, 5);
1020
1021 inner(usize::MAX, usize::MAX);
1022 inner(0_usize, 0);
1023 inner(5_usize, 5);
1024 }
1025
1026 fn inner(input: impl SqueezeTo_usize, expect: usize) {
1027 assert_eq!(input.squeeze_to(), expect);
1028 }
1029 }
1030}