oct 0.37.0

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! Tests for [`FromOctets`].

#![cfg(test)]

use core::cell::{Cell, UnsafeCell};
use core::cmp::Reverse;
use core::hint::black_box;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::{ManuallyDrop, MaybeUninit};
use core::num::{NonZero, Saturating, Wrapping};
use core::ptr::NonNull;
use oct::{
	fill,
	filled,
	FromOctets,
	IntoOctets,
	transmute_ref_with_metadata,
};

#[cfg(feature = "simd")]
use core::simd::Simd;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicPtr, AtomicUsize};

#[cfg(feature = "proc_macro")]
use oct::Zeroable;

#[cfg(feature = "proc_macro")]
#[test]
fn test_copy_from_octets_unaligned() {
	#[repr(align(16), C)]
	#[derive(FromOctets, Zeroable)]
	struct Aligned;

	#[repr(align(16), C)]
	#[derive(Default)]
	struct Octets([u8; 2]);

	let octets = &Octets::default().0[1..];

	let _ = Aligned::copy_from_octets(octets);
}

#[test]
#[should_panic]
fn test_copy_from_octets_unsized() {
	#[repr(align(4), C)]
	#[derive(Default)]
	struct Octets([u8; 3]);

	let octets = &Octets::default().0;

	let _ = i32::copy_from_octets(octets);
}

#[test]
fn test_filled() {
	#[track_caller]
	fn test<T: FromOctets>() {
		for value in u8::MIN..=u8::MAX {
			black_box(filled::<T>(value));
		}
	}

	test::<[usize; 00]>();
	test::<[usize; 01]>();
	test::<[usize; 02]>();
	test::<[usize; 03]>();
	test::<[usize; 04]>();
	test::<[usize; 05]>();
	test::<[usize; 06]>();
	test::<[usize; 07]>();
	test::<[usize; 08]>();
	test::<[usize; 09]>();
	test::<[usize; 10]>();
	test::<[usize; 11]>();
	test::<[usize; 12]>();
	test::<[usize; 13]>();
	test::<[usize; 14]>();
	test::<[usize; 15]>();
	test::<[usize; 16]>();
	test::<[usize; 17]>();
	test::<[usize; 18]>();
	test::<[usize; 19]>();
	test::<[usize; 20]>();
	test::<[usize; 21]>();
	test::<[usize; 22]>();
	test::<[usize; 23]>();
	test::<[usize; 24]>();
	test::<[usize; 25]>();
	test::<[usize; 26]>();
	test::<[usize; 27]>();
	test::<[usize; 28]>();
	test::<[usize; 29]>();
	test::<[usize; 30]>();
	test::<[usize; 31]>();
	test::<[usize; 32]>();
	test::<Cell<usize>>();
	test::<f32>();
	test::<f64>();
	test::<i128>();
	test::<i16>();
	test::<i32>();
	test::<i64>();
	test::<i8>();
	test::<isize>();
	test::<ManuallyDrop<usize>>();
	test::<MaybeUninit<bool>>(); // Pls use `!FromOctets`.
	test::<Option<NonNull<()>>>();
	test::<Option<NonZero<i128>>>();
	test::<Option<NonZero<i16>>>();
	test::<Option<NonZero<i32>>>();
	test::<Option<NonZero<i64>>>();
	test::<Option<NonZero<i8>>>();
	test::<Option<NonZero<isize>>>();
	test::<Option<NonZero<u128>>>();
	test::<Option<NonZero<u16>>>();
	test::<Option<NonZero<u32>>>();
	test::<Option<NonZero<u64>>>();
	test::<Option<NonZero<u8>>>();
	test::<Option<NonZero<usize>>>();
	test::<PhantomData<str>>(); // Pls use `!?Sized + !FromOctets`.
	test::<PhantomPinned>();
	test::<*const ()>();
	test::<*mut ()>();
	test::<Reverse<usize>>();
	test::<Saturating<usize>>();
	test::<(usize,)>();
	test::<(usize, usize)>();
	test::<(usize, usize, usize)>();
	test::<(usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)>();
	test::<(usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize, usize)>();
	test::<u128>();
	test::<u16>();
	test::<u32>();
	test::<u64>();
	test::<u8>();
	test::<()>();
	test::<usize>();
	test::<UnsafeCell<usize>>();
	test::<Wrapping<usize>>();

	#[cfg(feature = "f128")]
	test::<f128>();

	#[cfg(feature = "f16")]
	test::<f16>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 01>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 02>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 03>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 04>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 05>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 06>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 07>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 08>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 09>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 10>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 11>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 12>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 13>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 14>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 15>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 16>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 17>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 18>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 19>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 20>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 21>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 22>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 23>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 24>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 25>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 26>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 27>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 28>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 29>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 30>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 31>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 32>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 33>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 34>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 35>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 36>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 37>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 38>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 39>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 40>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 41>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 42>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 43>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 44>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 45>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 46>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 47>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 48>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 49>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 50>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 51>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 52>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 53>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 54>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 55>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 56>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 57>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 58>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 59>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 60>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 61>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 62>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 63>>();

	#[cfg(feature = "simd")]
	test::<Simd<usize, 64>>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::CpuidResult>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m128>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m128d>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m128i>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m256>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m256d>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m256i>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m512>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m512d>();

	#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
	test::<arch::__m512i>();

	#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
	test::<AtomicI128>();

	#[cfg(target_has_atomic = "16")]
	test::<AtomicI16>();

	#[cfg(target_has_atomic = "32")]
	test::<AtomicI32>();

	#[cfg(target_has_atomic = "64")]
	test::<AtomicI64>();

	#[cfg(target_has_atomic = "8")]
	test::<AtomicI8>();

	#[cfg(target_has_atomic = "ptr")]
	test::<AtomicIsize>();

	#[cfg(target_has_atomic = "ptr")]
	test::<AtomicPtr<()>>();

	#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
	test::<AtomicU128>();

	#[cfg(target_has_atomic = "16")]
	test::<AtomicU16>();

	#[cfg(target_has_atomic = "32")]
	test::<AtomicU32>();

	#[cfg(target_has_atomic = "64")]
	test::<AtomicU64>();

	#[cfg(target_has_atomic = "8")]
	test::<AtomicU8>();

	#[cfg(target_has_atomic = "ptr")]
	test::<AtomicUsize>();
}

#[test]
fn test_fill() {
	let mut value = (Option::<NonZero<u128>>::None, Option::<NonZero<i8>>::None);

	fill(&mut value, !0);

	assert_eq!(value.0.map(NonZero::get), Some(u128::MAX) );
	assert_eq!(value.1.map(NonZero::get), Some(-1) );

	fill(&mut value, 0x45);

	assert_eq!(value.0.map(NonZero::get), Some(0x45_45_45_45_45_45_45_45_45_45_45_45_45_45_45_45) );
	assert_eq!(value.1.map(NonZero::get), Some(0x45) );
}

#[test]
fn test_from_octets_with_len() {
	let octets = u128::MAX.as_octets();

	let len = size_of::<u128>() / size_of::<i16>();

	assert_eq!(
		transmute_ref_with_metadata::<[u8], [i16]>(octets, len),
		&[-1, -1, -1, -1, -1, -1, -1, -1],
	);
}