oct 0.36.2

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

//! Tests for [`Zeroable`].

#![cfg(test)]

#[cfg(any(miri, feature = "proc_macro"))]
use core::num::NonZero;

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

#[cfg(miri)]
use core::cell::{Cell, UnsafeCell};

#[cfg(miri)]
use core::cmp::Reverse;

#[cfg(miri)]
use core::hint::black_box;

#[cfg(miri)]
use core::marker::{PhantomData, PhantomPinned};

#[cfg(miri)]
use core::mem::{ManuallyDrop, MaybeUninit};

#[cfg(miri)]
use core::num::{Saturating, Wrapping};

#[cfg(miri)]
use core::ptr::NonNull;

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

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

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

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

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

#[cfg(all(miri, target_has_atomic = "ptr"))]
use core::sync::atomic::AtomicPtr;

#[cfg(feature = "proc_macro")]
#[test]
fn test_derive_zeroable() {
	#[derive(Zeroable)]
	struct _Type0;

	#[expect(clippy::empty_structs_with_brackets)]
	#[derive(Zeroable)]
	struct _Type1 {}

	#[derive(Zeroable)]
	struct _Type2(i32);

	#[derive(Zeroable)]
	struct _Type3 {
		_field0: i32,
	}

	#[repr(C)]
	#[derive(Zeroable)]
	enum _Type4 {
		_Variant0,
	}

	#[repr(i64)]
	#[derive(Zeroable)]
	enum _Type5 {
		_Variant0 = -1,
		_Variant1,
	}

	#[repr(i8)]
	#[derive(Zeroable)]
	enum _Type6 {
		_Variant0 = -2,
		_Variant1(NonZero<u8>),
		_Variant2(u8),
	}

	#[derive(Zeroable)]
	union _Type7 {
		_field0: Option<NonZero<i32>>,
		_field1: i32,
	}
}

#[cfg(feature = "alloc")]
#[test]
fn test_new_zeroed_boxed() {
	let array = <[i128; 4]>::new_zeroed_boxed_with_metadata(());
	let slice = <[i128]>::new_zeroed_boxed_with_metadata(4);

	assert_eq!(array.as_slice(), &[0; 4]);
	assert_eq!(&*slice, &[0; 4]);
}

#[cfg(all(feature = "alloc", miri))]
#[test]
fn test_new_zeroed_boxed_zst() {
	let _ = <()>::new_zeroed_boxed();

	let _ = <[i32]>::new_zeroed_boxed_with_metadata(0);

	let _ = <str>::new_zeroed_boxed_with_metadata(0);
}

#[cfg(miri)]
#[test]
fn test_new_zeroed() {
	fn test<T: Zeroable>() {
		fn test<T: Zeroable>() {
			let value = T::new_zeroed();
			black_box(value);
		}

		test::<T>();
		test::<[T; 00]>();
		test::<[T; 01]>();
		test::<[T; 02]>();
		test::<[T; 03]>();
		test::<[T; 04]>();
		test::<[T; 05]>();
		test::<[T; 06]>();
		test::<[T; 07]>();
		test::<[T; 08]>();
		test::<[T; 09]>();
		test::<[T; 10]>();
		test::<[T; 11]>();
		test::<[T; 12]>();
		test::<[T; 13]>();
		test::<[T; 13]>();
		test::<[T; 14]>();
		test::<[T; 15]>();
		test::<[T; 16]>();
		test::<[T; 17]>();
		test::<[T; 18]>();
		test::<[T; 19]>();
		test::<[T; 20]>();
		test::<[T; 21]>();
		test::<[T; 22]>();
		test::<[T; 23]>();
		test::<[T; 23]>();
		test::<[T; 24]>();
		test::<[T; 25]>();
		test::<[T; 26]>();
		test::<[T; 27]>();
		test::<[T; 28]>();
		test::<[T; 29]>();
		test::<[T; 30]>();
		test::<[T; 31]>();
		test::<[T; 32]>();
		test::<Cell<T>>();
		test::<ManuallyDrop<T>>();
		test::<MaybeUninit<T>>();
		test::<Option<NonNull<T>>>();
		test::<PhantomData<T>>();
		test::<*const T>();
		test::<*mut T>();
		test::<Reverse<T>>();
		test::<Saturating<T>>();
		test::<(T,)>();
		test::<(T, T)>();
		test::<(T, T, T)>();
		test::<(T, T, T, T)>();
		test::<(T, T, T, T, T)>();
		test::<(T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T, T, T, T, T)>();
		test::<(T, T, T, T, T, T, T, T, T, T, T, T)>();
		test::<UnsafeCell<T>>();
		test::<Wrapping<T>>();

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

	test::<bool>();
	test::<char>();
	test::<f32>();
	test::<f64>();
	test::<i128>();
	test::<i16>();
	test::<i32>();
	test::<i64>();
	test::<i8>();
	test::<isize>();
	test::<Option<NonNull<u8>>>();
	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::<PhantomPinned>();
	test::<u128>();
	test::<u16>();
	test::<u32>();
	test::<u64>();
	test::<u8>();
	test::<()>();
	test::<usize>();

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

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

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

	#[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(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>();
}