#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks
fn alloc_owned_small(b: &mut Bencher) {
b.iter(|| {
- let _: Box<_> = box 10;
+ let _: Box<_> = Box::new(10);
})
}
#[test]
fn test_push_unique() {
- let mut heap = BinaryHeap::<Box<_>>::from(vec![box 2, box 4, box 9]);
+ let mut heap = BinaryHeap::<Box<_>>::from(vec![Box::new(2), Box::new(4), Box::new(9)]);
assert_eq!(heap.len(), 3);
assert!(**heap.peek().unwrap() == 9);
- heap.push(box 11);
+ heap.push(Box::new(11));
assert_eq!(heap.len(), 4);
assert!(**heap.peek().unwrap() == 11);
- heap.push(box 5);
+ heap.push(Box::new(5));
assert_eq!(heap.len(), 5);
assert!(**heap.peek().unwrap() == 11);
- heap.push(box 27);
+ heap.push(Box::new(27));
assert_eq!(heap.len(), 6);
assert!(**heap.peek().unwrap() == 27);
- heap.push(box 3);
+ heap.push(Box::new(3));
assert_eq!(heap.len(), 7);
assert!(**heap.peek().unwrap() == 27);
- heap.push(box 103);
+ heap.push(Box::new(103));
assert_eq!(heap.len(), 8);
assert!(**heap.peek().unwrap() == 103);
}
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn push_front(&mut self, elt: T) {
- self.push_front_node(box Node::new(elt));
+ self.push_front_node(Box::new(Node::new(elt)));
}
/// Removes the first element and returns it, or `None` if the list is
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn push_back(&mut self, elt: T) {
- self.push_back_node(box Node::new(elt));
+ self.push_back_node(Box::new(Node::new(elt)));
}
/// Removes the last element from a list and returns it, or `None` if
assert_eq!(m.pop_front(), None);
assert_eq!(m.pop_back(), None);
assert_eq!(m.pop_front(), None);
- m.push_front(box 1);
- assert_eq!(m.pop_front(), Some(box 1));
- m.push_back(box 2);
- m.push_back(box 3);
+ m.push_front(Box::new(1));
+ assert_eq!(m.pop_front(), Some(Box::new(1)));
+ m.push_back(Box::new(2));
+ m.push_back(Box::new(3));
assert_eq!(m.len(), 2);
- assert_eq!(m.pop_front(), Some(box 2));
- assert_eq!(m.pop_front(), Some(box 3));
+ assert_eq!(m.pop_front(), Some(Box::new(2)));
+ assert_eq!(m.pop_front(), Some(Box::new(3)));
assert_eq!(m.len(), 0);
assert_eq!(m.pop_front(), None);
- m.push_back(box 1);
- m.push_back(box 3);
- m.push_back(box 5);
- m.push_back(box 7);
- assert_eq!(m.pop_front(), Some(box 1));
+ m.push_back(Box::new(1));
+ m.push_back(Box::new(3));
+ m.push_back(Box::new(5));
+ m.push_back(Box::new(7));
+ assert_eq!(m.pop_front(), Some(Box::new(1)));
let mut n = LinkedList::new();
n.push_front(2);
// if the weak pointer is stored inside the strong one.
unsafe {
Self::from_inner(
- Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(),
+ Box::leak(Box::new(RcBox { strong: Cell::new(1), weak: Cell::new(1), value }))
+ .into(),
)
}
}
{
// Construct the inner in the "uninitialized" state with a single
// weak reference.
- let uninit_ptr: NonNull<_> = Box::leak(box RcBox {
+ let uninit_ptr: NonNull<_> = Box::leak(Box::new(RcBox {
strong: Cell::new(0),
weak: Cell::new(1),
value: mem::MaybeUninit::<T>::uninit(),
- })
+ }))
.into();
let init_ptr: NonNull<RcBox<T>> = uninit_ptr.cast();
#[test]
fn test_destructor() {
- let x: Rc<Box<_>> = Rc::new(box 5);
+ let x: Rc<Box<_>> = Rc::new(Box::new(5));
assert_eq!(**x, 5);
}
#[test]
fn into_from_raw() {
- let x = Rc::new(box "hello");
+ let x = Rc::new(Box::new("hello"));
let y = x.clone();
let x_ptr = Rc::into_raw(x);
#[test]
fn into_from_weak_raw() {
- let x = Rc::new(box "hello");
+ let x = Rc::new(Box::new("hello"));
let y = Rc::downgrade(&x);
let y_ptr = Weak::into_raw(y);
#[test]
fn test_from_box() {
- let b: Box<u32> = box 123;
+ let b: Box<u32> = Box::new(123);
let r: Rc<u32> = Rc::from(b);
assert_eq!(*r, 123);
use std::fmt::Display;
use std::string::ToString;
- let b: Box<dyn Display> = box 123;
+ let b: Box<dyn Display> = Box::new(123);
let r: Rc<dyn Display> = Rc::from(b);
assert_eq!(r.to_string(), "123");
fn test_from_box_trait_zero_sized() {
use std::fmt::Debug;
- let b: Box<dyn Debug> = box ();
+ let b: Box<dyn Debug> = Box::new(());
let r: Rc<dyn Debug> = Rc::from(b);
assert_eq!(format!("{r:?}"), "()");
pub fn new(data: T) -> Arc<T> {
// Start the weak pointer count as 1 which is the weak pointer that's
// held by all the strong pointers (kinda), see std/rc.rs for more info
- let x: Box<_> = box ArcInner {
+ let x: Box<_> = Box::new(ArcInner {
strong: atomic::AtomicUsize::new(1),
weak: atomic::AtomicUsize::new(1),
data,
- };
+ });
unsafe { Self::from_inner(Box::leak(x).into()) }
}
{
// Construct the inner in the "uninitialized" state with a single
// weak reference.
- let uninit_ptr: NonNull<_> = Box::leak(box ArcInner {
+ let uninit_ptr: NonNull<_> = Box::leak(Box::new(ArcInner {
strong: atomic::AtomicUsize::new(0),
weak: atomic::AtomicUsize::new(1),
data: mem::MaybeUninit::<T>::uninit(),
- })
+ }))
.into();
let init_ptr: NonNull<ArcInner<T>> = uninit_ptr.cast();
#[test]
fn into_from_raw() {
- let x = Arc::new(box "hello");
+ let x = Arc::new(Box::new("hello"));
let y = x.clone();
let x_ptr = Arc::into_raw(x);
#[test]
fn into_from_weak_raw() {
- let x = Arc::new(box "hello");
+ let x = Arc::new(Box::new("hello"));
let y = Arc::downgrade(&x);
let y_ptr = Weak::into_raw(y);
#[test]
fn test_from_box() {
- let b: Box<u32> = box 123;
+ let b: Box<u32> = Box::new(123);
let r: Arc<u32> = Arc::from(b);
assert_eq!(*r, 123);
use std::fmt::Display;
use std::string::ToString;
- let b: Box<dyn Display> = box 123;
+ let b: Box<dyn Display> = Box::new(123);
let r: Arc<dyn Display> = Arc::from(b);
assert_eq!(r.to_string(), "123");
fn test_from_box_trait_zero_sized() {
use std::fmt::Debug;
- let b: Box<dyn Debug> = box ();
+ let b: Box<dyn Debug> = Box::new(());
let r: Arc<dyn Debug> = Arc::from(b);
assert_eq!(format!("{r:?}"), "()");
fn test_swap_remove_noncopyable() {
// Tests that we don't accidentally run destructors twice.
let mut v: Vec<Box<_>> = Vec::new();
- v.push(box 0);
- v.push(box 0);
- v.push(box 0);
+ v.push(Box::new(0));
+ v.push(Box::new(0));
+ v.push(Box::new(0));
let mut _e = v.swap_remove(0);
assert_eq!(v.len(), 2);
_e = v.swap_remove(1);
#[test]
fn test_truncate() {
- let mut v: Vec<Box<_>> = vec![box 6, box 5, box 4];
+ let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
v.truncate(1);
let v = v;
assert_eq!(v.len(), 1);
#[test]
fn test_clear() {
- let mut v: Vec<Box<_>> = vec![box 6, box 5, box 4];
+ let mut v: Vec<Box<_>> = vec![Box::new(6), Box::new(5), Box::new(4)];
v.clear();
assert_eq!(v.len(), 0);
// If the unsafe block didn't drop things properly, we blow up here.
#[test]
fn test_to_vec() {
- let xs: Box<_> = box [1, 2, 3];
+ let xs: Box<_> = Box::new([1, 2, 3]);
let ys = xs.to_vec();
assert_eq!(ys, [1, 2, 3]);
}
#[test]
fn test_in_place_iterator_specialization() {
- let src: Box<[usize]> = box [1, 2, 3];
+ let src: Box<[usize]> = Box::new([1, 2, 3]);
let src_ptr = src.as_ptr();
let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect();
let sink_ptr = sink.as_ptr();
#[test]
fn test_clone_from() {
let mut v = vec![];
- let three: Vec<Box<_>> = vec![box 1, box 2, box 3];
- let two: Vec<Box<_>> = vec![box 4, box 5];
+ let three: Vec<Box<_>> = vec![Box::new(1), Box::new(2), Box::new(3)];
+ let two: Vec<Box<_>> = vec![Box::new(4), Box::new(5)];
// zero, long
v.clone_from(&three);
assert_eq!(v, three);
#[test]
fn test_dedup_unique() {
- let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
+ let mut v0: Vec<Box<_>> = vec![Box::new(1), Box::new(1), Box::new(2), Box::new(3)];
v0.dedup();
- let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
+ let mut v1: Vec<Box<_>> = vec![Box::new(1), Box::new(2), Box::new(2), Box::new(3)];
v1.dedup();
- let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
+ let mut v2: Vec<Box<_>> = vec![Box::new(1), Box::new(2), Box::new(3), Box::new(3)];
v2.dedup();
// If the boxed pointers were leaked or otherwise misused, valgrind
// and/or rt should raise errors.