Add crate tests (#10)

* Add tests/vec.rs

* Add default generic to `vec::` structs

* Use global allocator instead of `AbortAlloc`

* Add heap tests

* Add uninitialized_zero_size_box tests

* Add string tests (as much as possible)

* Don't use alloc_wg::string::String in vec tests as of missing features

* Fix string and heap tests

Those tests failed as `to_string` is not possible for downstream crates

Author: TimDiekmann

src/boxed.rs

@@ -398,9 +398,10 @@ impl<T, A: AllocRef> Box<[T], A> {
             let layout = NonZeroLayout::array::<mem::MaybeUninit<T>>(len)?;
             a.alloc(layout)
                 .map_err(|inner| CollectionAllocErr::AllocError { layout, inner })?
+                .cast()
         };
         unsafe {
-            let slice = slice::from_raw_parts_mut(ptr.cast().as_ptr(), len);
+            let slice = slice::from_raw_parts_mut(ptr.as_ptr(), len);
             Ok(Box::from_raw_in(
                 NonNull::from(slice).as_ptr(),
                 a.get_build_alloc(),

src/vec.rs

@@ -2833,7 +2833,7 @@ impl<T> Drop for IntoIter<T> {
 ///
 /// [`drain`]: struct.Vec.html#method.drain
 /// [`Vec`]: struct.Vec.html
-pub struct Drain<'a, T, A: DeallocRef> {
+pub struct Drain<'a, T, A: DeallocRef = AbortAlloc<Global>> {
     /// Index of tail to preserve
     tail_start: usize,
     /// Length of tail
@@ -2926,7 +2926,7 @@ impl<T, A: DeallocRef> FusedIterator for Drain<'_, T, A> {}
 /// [`splice()`]: struct.Vec.html#method.splice
 /// [`Vec`]: struct.Vec.html
 #[derive(Debug)]
-pub struct Splice<'a, I: Iterator + 'a, A>
+pub struct Splice<'a, I: Iterator + 'a, A = AbortAlloc<Global>>
 where
     A: ReallocRef<Error = crate::Never>,
 {
@@ -3049,7 +3049,7 @@ where
 
 /// An iterator produced by calling `drain_filter` on Vec.
 // #[derive(Debug)]
-pub struct DrainFilter<'a, T, F, A: DeallocRef>
+pub struct DrainFilter<'a, T, F, A: DeallocRef = AbortAlloc<Global>>
 where
     F: FnMut(&mut T) -> bool,
 {
@@ -3112,7 +3112,7 @@ where
     F: FnMut(&mut T) -> bool,
 {
     fn drop(&mut self) {
-        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef>
+        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef = AbortAlloc<Global>>
         where
             F: FnMut(&mut T) -> bool,
         {

tests/boxed.rs

@@ -0,0 +1,18 @@
+use alloc_wg::boxed::Box;
+use core::{mem::MaybeUninit, ptr::NonNull};
+
+#[test]
+fn unitialized_zero_size_box() {
+    assert_eq!(
+        &*Box::<()>::new_uninit() as *const _,
+        NonNull::<MaybeUninit<()>>::dangling().as_ptr(),
+    );
+    assert_eq!(
+        Box::<[()]>::new_uninit_slice(4).as_ptr(),
+        NonNull::<MaybeUninit<()>>::dangling().as_ptr(),
+    );
+    assert_eq!(
+        Box::<[String]>::new_uninit_slice(0).as_ptr(),
+        NonNull::<MaybeUninit<String>>::dangling().as_ptr(),
+    );
+}

tests/heap.rs

@@ -0,0 +1,48 @@
+use alloc_wg::alloc::{AllocRef, Global, NonZeroLayout};
+use core::fmt::Debug;
+
+/// Issue #45955 and #62251.
+#[test]
+#[cfg(feature = "std")]
+fn alloc_system_overaligned_request() {
+    check_overalign_requests(std::alloc::System)
+}
+
+#[test]
+fn std_heap_overaligned_request() {
+    check_overalign_requests(Global)
+}
+
+fn check_overalign_requests<T: AllocRef>(mut allocator: T)
+where
+    T::Error: Debug,
+{
+    for &align in &[4, 8, 16, 32] {
+        // less than and bigger than `MIN_ALIGN`
+        for &size in &[align / 2, align - 1] {
+            // size less than alignment
+            let iterations = 128;
+            unsafe {
+                let pointers: Vec<_> = (0..iterations)
+                    .map(|_| {
+                        allocator
+                            .alloc(NonZeroLayout::from_size_align(size, align).unwrap())
+                            .unwrap()
+                    })
+                    .collect();
+                for &ptr in &pointers {
+                    assert_eq!(
+                        (ptr.as_ptr() as usize) % align,
+                        0,
+                        "Got a pointer less aligned than requested"
+                    )
+                }
+
+                // Clean up
+                for &ptr in &pointers {
+                    allocator.dealloc(ptr, NonZeroLayout::from_size_align(size, align).unwrap())
+                }
+            }
+        }
+    }
+}