unsafe {

self.current = unlinked_node.as_ref().next;

self.list.unlink_node(unlinked_node);

let unlinked_node = Box::from_raw(unlinked_node.as_ptr());

let unlinked_node = Box::from_raw_in(unlinked_node.as_ptr(), &self.list.alloc);

Some(unlinked_node.element)

}

}

if (self.pred)(&mut node.as_mut().element) {

// `unlink_node` is okay with aliasing `element` references.

self.list.unlink_node(node);

return Some(Box::from_raw(node.as_ptr()).element);

return Some(Box::from_raw_in(node.as_ptr(), &self.list.alloc).element);

}

}

}

assert_eq!(unsafe { DROPS }, 8);

}

#[test]

fn test_allocator() {

use core::alloc::AllocError;

use core::alloc::Allocator;

use core::alloc::Layout;

use core::cell::Cell;

struct A {

has_allocated: Cell<bool>,

has_deallocated: Cell<bool>,

}

unsafe impl Allocator for A {

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {

assert!(!self.has_allocated.get());

self.has_allocated.set(true);

Global.allocate(layout)

}

unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {

assert!(!self.has_deallocated.get());

self.has_deallocated.set(true);

unsafe { Global.deallocate(ptr, layout) }

}

}

let alloc = &A { has_allocated: Cell::new(false), has_deallocated: Cell::new(false) };

{

let mut list = LinkedList::new_in(alloc);

list.push_back(5u32);

list.remove(0);

}

assert!(alloc.has_allocated.get());

assert!(alloc.has_deallocated.get());

}