test coverage: start testing reallocs, check in tests for passing allocators

MaulingMonkey · MaulingMonkey · commit 1c7a7c82a244 · 2025-05-01T10:18:13.000-07:00
relates to #32
diff --git a/src/allocator/alloc/global.rs b/src/allocator/alloc/global.rs
@@ -205,5 +205,7 @@ unsafe impl core::alloc::GlobalAlloc for Global {
 #[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 !GLOBAL_ALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(Global) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(Global) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(Global) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(Global) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(Global) }
diff --git a/src/allocator/cpp/new_delete.rs b/src/allocator/cpp/new_delete.rs
@@ -100,11 +100,15 @@ unsafe impl fat::Realloc for 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 !OPERATOR_NEW_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(NewDelete) } } }
+//test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(NewDelete) } // does not implement thin::Realloc
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(NewDelete) }
+//test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(NewDelete) } // does not implement thin::Realloc
 #[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 !OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDelete) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(NewDelete) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDelete) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(NewDelete) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDelete) }
diff --git a/src/allocator/cpp/new_delete_aligned.rs b/src/allocator/cpp/new_delete_aligned.rs
@@ -82,5 +82,7 @@ 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 !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteAligned) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(NewDeleteAligned) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteAligned) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(NewDeleteAligned) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteAligned) }
diff --git a/src/allocator/cpp/new_delete_array.rs b/src/allocator/cpp/new_delete_array.rs
@@ -95,11 +95,15 @@ unsafe impl fat::Realloc for 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 !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(NewDeleteArray) } } }
+//test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(NewDeleteArray) } // does not implement thin::Realloc
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(NewDeleteArray) }
+//test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(NewDeleteArray) } // does not implement thin::Realloc
 #[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 !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArray) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(NewDeleteArray) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteArray) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(NewDeleteArray) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteArray) }
diff --git a/src/allocator/cpp/new_delete_array_aligned.rs b/src/allocator/cpp/new_delete_array_aligned.rs
@@ -82,5 +82,7 @@ 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 !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(NewDeleteArrayAligned) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(NewDeleteArrayAligned) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(NewDeleteArrayAligned) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(NewDeleteArrayAligned) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(NewDeleteArrayAligned) }
diff --git a/src/allocator/cpp/std_allocator.rs b/src/allocator/cpp/std_allocator.rs
@@ -107,5 +107,7 @@ 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 !allocator::cpp::OPERATOR_NEW_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(StdAllocator::<c_char>::new()) } } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(StdAllocator::<c_char>::new()) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(StdAllocator::<c_char>::new()) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(StdAllocator::<c_char>::new()) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_conservative(StdAllocator::<c_char>::new()) }
diff --git a/src/allocator/debug/null.rs b/src/allocator/debug/null.rs
@@ -90,5 +90,7 @@ unsafe impl fat::Realloc for Null {
 #[test] fn thin_nullable()          { thin::test::nullable(Null) }
 #[test] fn thin_size()              { thin::test::size_exact_alloc(Null) }
 #[test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(Null) } }
+#[test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(Null) }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(Null) }
+#[test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(Null) }
 //#[test] fn thin_zst_support() { thin::test::zst_supported_conservative(Null) } // XXX: Null intentionally claims support for anything but won't ever allocate
diff --git a/src/allocator/simple/bump.rs b/src/allocator/simple/bump.rs
@@ -172,5 +172,7 @@ unsafe impl<'a> fat::Realloc for Bump<'a> {
 #[test] fn fat_alignment()          { fat::test::alignment(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
 #[test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(&Bump::from_array(&mut MaybeUninit::new([(); 131072].map(|_| MaybeUninit::<u8>::new(0xFF))))) }
diff --git a/src/allocator/simple/fixed_pool.rs b/src/allocator/simple/fixed_pool.rs
@@ -219,11 +219,15 @@ type Element<const A : usize, const B : usize> = UnsafeCell<MaybeUninit<AlignN<A
 #[test] fn thin_nullable()          { thin::test::nullable(&FixedPoolLinearProbe::<4, 4, 1024>::new()) }
 //#[test] fn thin_size()              { thin::test::size_over_alloc(&FixedPoolLinearProbe::<4, 4, 1024>::new()) } // NYI
 #[test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(&FixedPoolLinearProbe::<4, 4, 128>::new()) } }
+#[test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
+#[test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
 #[test] fn thin_zst_support()       { thin::test::zst_supported_accurate(&FixedPoolLinearProbe::<4, 4, 1024>::new()) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(&FixedPoolLinearProbe::<4, 4, 1024>::new()) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(&FixedPoolLinearProbe::<4, 4, 1024>::new()) }
 #[test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(&FixedPoolLinearProbe::<4, 4, 128>::new()) } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(&FixedPoolLinearProbe::<4, 4, 128>::new()) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(&FixedPoolLinearProbe::<4, 4, 1024>::new()) }
diff --git a/src/allocator/win32/cryptmem.rs b/src/allocator/win32/cryptmem.rs
@@ -127,13 +127,17 @@ unsafe impl thin::Free for CryptMem {
 #[test] fn thin_alignment()         { thin::test::alignment(CryptMem) }
 #[test] fn thin_edge_case_sizes()   { thin::test::edge_case_sizes(CryptMem) }
 #[test] fn thin_nullable()          { thin::test::nullable(CryptMem) }
-//#[test] fn thin_size()              { ...no CryptMemSizeOf... }
-//#[test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(CryptMem) } } // Interestingly, CryptMem appears to zero it's memory.  This isn't documented, so I choose not to rely on it, but it's interesting...
+//test] fn thin_size()              { ...no CryptMemSizeOf... }
+//test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(CryptMem) } } // Interestingly, CryptMem appears to zero it's memory.  This isn't documented, so I choose not to rely on it, but it's interesting...
+#[test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(CryptMem) }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(CryptMem) }
+#[test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(CryptMem) }
 #[test] fn thin_zst_support()       { thin::test::zst_supported_accurate(CryptMem) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(CryptMem) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(CryptMem) }
-//#[test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(CryptMem) } } // CryptMem is always zeroed
+//test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(CryptMem) } } // CryptMem is always zeroed
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(CryptMem) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(CryptMem) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(CryptMem) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(CryptMem) }
diff --git a/src/allocator/win32/heap.rs b/src/allocator/win32/heap.rs
@@ -406,13 +406,27 @@ unsafe impl thin::SizeOfDebug   for ProcessHeap { unsafe fn size_of_debug(&self,
     }
 }
 
+#[test] fn thin_uninit_realloc() {
+    thin::test::uninit_realloc(ProcessHeap);
+    thin::test::uninit_realloc(create_test_heap(None, None));
+    thin::test::uninit_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+    Heap::with_process(|heap| thin::test::uninit_realloc(heap));
+}
+
 #[test] fn thin_zeroed() {
     thin::test::zeroed_alloc(ProcessHeap);
     thin::test::zeroed_alloc(create_test_heap(None, None));
     thin::test::zeroed_alloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
     Heap::with_process(|heap| thin::test::zeroed_alloc(heap));
 }
 
+#[test] fn thin_zeroed_realloc() {
+    thin::test::zeroed_realloc(ProcessHeap);
+    thin::test::zeroed_realloc(create_test_heap(None, None));
+    thin::test::zeroed_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+    Heap::with_process(|heap| thin::test::zeroed_realloc(heap));
+}
+
 #[test] fn thin_zst_support() {
     thin::test::zst_supported_accurate(ProcessHeap);
     thin::test::zst_supported_accurate(create_test_heap(None, None));
@@ -443,13 +457,27 @@ unsafe impl thin::SizeOfDebug   for ProcessHeap { unsafe fn size_of_debug(&self,
     Heap::with_process(|heap| unsafe { fat::test::uninit_alloc_unsound(heap) });
 }
 
+#[test] fn fat_uninit_realloc() {
+    fat::test::uninit_realloc(ProcessHeap);
+    fat::test::uninit_realloc(create_test_heap(None, None));
+    fat::test::uninit_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+    Heap::with_process(|heap| fat::test::uninit_realloc(heap));
+}
+
 #[test] fn fat_zeroed() {
     fat::test::zeroed_alloc(ProcessHeap);
     fat::test::zeroed_alloc(create_test_heap(None, None));
     fat::test::zeroed_alloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
     Heap::with_process(|heap| fat::test::zeroed_alloc(heap));
 }
 
+#[test] fn fat_zeroed_realloc() {
+    fat::test::zeroed_realloc(ProcessHeap);
+    fat::test::zeroed_realloc(create_test_heap(None, None));
+    fat::test::zeroed_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+    Heap::with_process(|heap| fat::test::zeroed_realloc(heap));
+}
+
 #[test] fn fat_zst_support() {
     fat::test::zst_supported_accurate(ProcessHeap);
     fat::test::zst_supported_accurate(create_test_heap(None, None));
diff --git a/src/allocator/win32/heap_no_serialize.rs b/src/allocator/win32/heap_no_serialize.rs
@@ -287,11 +287,21 @@ unsafe impl thin::SizeOfDebug for HeapNoSerialize {
     }
 }
 
+#[test] fn thin_uninit_realloc() {
+    thin::test::uninit_realloc(create_test_heap(None, None));
+    thin::test::uninit_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+}
+
 #[test] fn thin_zeroed() {
     thin::test::zeroed_alloc(create_test_heap(None, None));
     thin::test::zeroed_alloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
 }
 
+#[test] fn thin_zeroed_realloc() {
+    thin::test::zeroed_realloc(create_test_heap(None, None));
+    thin::test::zeroed_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+}
+
 #[test] fn thin_zst_support() {
     thin::test::zst_supported_accurate(create_test_heap(None, None));
     thin::test::zst_supported_accurate(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
@@ -314,11 +324,21 @@ unsafe impl thin::SizeOfDebug for HeapNoSerialize {
     unsafe { fat::test::uninit_alloc_unsound(create_test_heap(None, NonZeroUsize::new(1024 * 1024))) };
 }
 
+#[test] fn fat_uninit_realloc() {
+    fat::test::uninit_realloc(create_test_heap(None, None));
+    fat::test::uninit_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+}
+
 #[test] fn fat_zeroed() {
     fat::test::zeroed_alloc(create_test_heap(None, None));
     fat::test::zeroed_alloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
 }
 
+#[test] fn fat_zeroed_realloc() {
+    fat::test::zeroed_realloc(create_test_heap(None, None));
+    fat::test::zeroed_realloc(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
+}
+
 #[test] fn fat_zst_support() {
     fat::test::zst_supported_accurate(create_test_heap(None, None));
     fat::test::zst_supported_accurate(create_test_heap(None, NonZeroUsize::new(1024 * 1024)));
diff --git a/src/allocator/win32/virtual_.rs b/src/allocator/win32/virtual_.rs
@@ -110,12 +110,16 @@ unsafe impl fat::Realloc for VirtualCommit {}
 #[test] fn thin_alignment()         { thin::test::alignment(VirtualCommit) }
 #[test] fn thin_edge_case_sizes()   { thin::test::edge_case_sizes(VirtualCommit) }
 #[test] fn thin_nullable()          { thin::test::nullable(VirtualCommit) }
-//#[test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(VirtualCommit) } } // VirtualCommit is always zeroed
+//test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(VirtualCommit) } } // VirtualCommit is always zeroed
+//test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(VirtualCommit) } // does not implement thin::Realloc
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(VirtualCommit) }
+//test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(VirtualCommit) } // does not implement thin::Realloc
 #[test] fn thin_zst_support()       { thin::test::zst_supported_accurate(VirtualCommit) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(VirtualCommit) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(VirtualCommit) }
-//#[test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(VirtualCommit) } } // VirtualCommit is always zeroed
+//test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(VirtualCommit) } } // VirtualCommit is always zeroed
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(VirtualCommit) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(VirtualCommit) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(VirtualCommit) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(VirtualCommit) }
diff --git a/src/traits/fat.rs b/src/traits/fat.rs
diff --git a/src/traits/thin.rs b/src/traits/thin.rs
