fix CI: note that many allocators zero init on macos-latest

Author: MaulingMonkey

src/allocator/alloc/global.rs

@@ -197,8 +197,13 @@ unsafe impl core::alloc::GlobalAlloc for Global {
 
 
 
+#[cfg(test)] const GLOBAL_ALLOC_ZERO_INITS : bool = cfg!(any(
+    target_os = "linux",    // from the start of `ialloc` on CI and WSL
+    target_os = "macos",    // github's `macos-11` runners didn't zero init, but `macos-14`(? via `macos-latest`) does.
+));
+
 #[test] fn fat_alignment()          { fat::test::alignment(Global) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(Global) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(Global) } } }
+#[test] fn fat_uninit()             { if !GLOBAL_ALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(Global) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(Global) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(Global) }

src/allocator/c/aligned_malloc.rs

@@ -259,8 +259,13 @@ mod ffi {
 
 
 
+#[cfg(test)] const ALIGNED_ALLOC_ZERO_INITS : bool = cfg!(any(
+    target_os = "linux",    // from the start of `ialloc` on CI and WSL
+    target_os = "macos",    // github's `macos-11` runners didn't zero init, but `macos-14`(? via `macos-latest`) does.
+));
+
 #[test] fn fat_alignment()              { fat::test::alignment(AlignedMalloc) }
 #[test] fn fat_edge_case_sizes()        { fat::test::edge_case_sizes(AlignedMalloc) }
-#[test] fn fat_uninit()                 { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(AlignedMalloc) } } } // malloc returns zeroed memory on some platforms
+#[test] fn fat_uninit()                 { if !ALIGNED_ALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(AlignedMalloc) } } }
 #[test] fn fat_zeroed()                 { fat::test::zeroed_alloc(AlignedMalloc) }
 #[test] fn fat_zst_support()            { fat::test::zst_supported_conservative(AlignedMalloc) }

src/allocator/c/malloc.rs

@@ -187,19 +187,24 @@ unsafe impl thin::SizeOfDebug for Malloc {
 
 
 
+#[cfg(test)] const MALLOC_ZERO_INITS : bool = cfg!(any(
+    target_os = "linux",    // from the start of `ialloc` on CI and WSL
+    target_os = "macos",    // github's `macos-11` runners didn't zero init, but `macos-14`(? via `macos-latest`) does.
+));
+
 #[test] fn thin_alignment()             { thin::test::alignment(Malloc) }
 #[test] fn thin_edge_case_sizes()       { thin::test::edge_case_sizes(Malloc) }
 #[test] fn thin_nullable()              { thin::test::nullable(Malloc) }
 #[test] fn thin_size()                  { thin::test::size_over_alloc(Malloc) }
-#[test] fn thin_uninit()                { if !cfg!(target_os = "linux") { unsafe { thin::test::uninit_alloc_unsound(Malloc) } } } // malloc returns zeroed memory on some platforms
+#[test] fn thin_uninit()                { if !MALLOC_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(Malloc) } } }
 #[test] fn thin_zeroed()                { thin::test::zeroed_alloc(Malloc) }
 #[test] fn thin_zst_support()           { thin::test::zst_supported_conservative(Malloc) }
 #[test] fn thin_zst_support_dangle()    { thin::test::zst_supported_conservative(crate::allocator::adapt::DangleZst(Malloc)) }
 #[test] fn thin_zst_support_alloc()     { thin::test::zst_supported_conservative(crate::allocator::adapt::AllocZst(Malloc)) }
 
 #[test] fn fat_alignment()              { fat::test::alignment(Malloc) }
 #[test] fn fat_edge_case_sizes()        { fat::test::edge_case_sizes(Malloc) }
-#[test] fn fat_uninit()                 { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(Malloc) } } } // malloc returns zeroed memory on some platforms
+#[test] fn fat_uninit()                 { if !MALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(Malloc) } } }
 #[test] fn fat_zeroed()                 { fat::test::zeroed_alloc(Malloc) }
 #[test] fn fat_zst_support()            { fat::test::zst_supported_conservative(Malloc) }
 #[test] fn fat_zst_support_dangle()     { fat::test::zst_supported_conservative(crate::allocator::adapt::DangleZst(Malloc)) }

src/allocator/cpp/new_delete.rs

@@ -91,15 +91,20 @@ unsafe impl fat::Realloc for NewDelete {}
 
 
 
+#[cfg(test)] pub(crate) const OPERATOR_NEW_ZERO_INITS : bool = cfg!(any(
+    target_os = "linux",    // from the start of `ialloc` on CI and WSL
+    target_os = "macos",    // github's `macos-11` runners didn't zero init, but `macos-14`(? via `macos-latest`) does.
+));
+
 #[test] fn thin_alignment()         { thin::test::alignment(NewDelete) }
 #[test] fn thin_edge_case_sizes()   { thin::test::edge_case_sizes(NewDelete) }
 #[test] fn thin_nullable()          { thin::test::nullable(NewDelete) }
-#[test] fn thin_uninit()            { if !cfg!(target_os = "linux") { unsafe { thin::test::uninit_alloc_unsound(NewDelete) } } } // `::operator new` returns zeroed memory on some platforms
+#[test] fn thin_uninit()            { if !OPERATOR_NEW_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(NewDelete) } } }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(NewDelete) }
 #[test] fn thin_zst_support()       { thin::test::zst_supported_conservative(NewDelete) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(NewDelete) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(NewDelete) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(NewDelete) } } }
+#[test] fn fat_uninit()             { if !OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDelete) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDelete) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDelete) }

src/allocator/cpp/new_delete_aligned.rs

@@ -81,6 +81,6 @@ unsafe impl fat::Realloc for NewDeleteAligned {}
 
 #[test] fn fat_alignment()          { fat::test::alignment(NewDeleteAligned) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(NewDeleteAligned) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(NewDeleteAligned) } } }
+#[test] fn fat_uninit()             { if !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteAligned) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteAligned) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteAligned) }

src/allocator/cpp/new_delete_array.rs

@@ -94,12 +94,12 @@ unsafe impl fat::Realloc for NewDeleteArray {}
 #[test] fn thin_alignment()         { thin::test::alignment(NewDeleteArray) }
 #[test] fn thin_edge_case_sizes()   { thin::test::edge_case_sizes(NewDeleteArray) }
 #[test] fn thin_nullable()          { thin::test::nullable(NewDeleteArray) }
-#[test] fn thin_uninit()            { if !cfg!(target_os = "linux") { unsafe { thin::test::uninit_alloc_unsound(NewDeleteArray) } } } // `::operator new[]` returns zeroed memory on some platforms
+#[test] fn thin_uninit()            { if !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(NewDeleteArray) } } }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(NewDeleteArray) }
 #[test] fn thin_zst_support()       { thin::test::zst_supported_conservative(NewDeleteArray) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(NewDeleteArray) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(NewDeleteArray) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArray) } } }
+#[test] fn fat_uninit()             { if !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArray) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteArray) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteArray) }

src/allocator/cpp/new_delete_array_aligned.rs

@@ -81,6 +81,6 @@ unsafe impl fat::Realloc for NewDeleteArrayAligned {}
 
 #[test] fn fat_alignment()          { fat::test::alignment(NewDeleteArrayAligned) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(NewDeleteArrayAligned) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArrayAligned) } } }
+#[test] fn fat_uninit()             { if !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArrayAligned) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteArrayAligned) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteArrayAligned) }

src/allocator/cpp/std_allocator.rs

@@ -106,6 +106,6 @@ unsafe impl fat::Realloc for StdAllocator<c_char> {}
 
 #[test] fn fat_alignment()          { fat::test::alignment(StdAllocator::<c_char>::new()) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(StdAllocator::<c_char>::new()) }
-#[test] fn fat_uninit()             { if !cfg!(target_os = "linux") { unsafe { fat::test::uninit_alloc_unsound(StdAllocator::<c_char>::new()) } } }
+#[test] fn fat_uninit()             { if !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(StdAllocator::<c_char>::new()) } } }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(StdAllocator::<c_char>::new()) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(StdAllocator::<c_char>::new()) }