From 69aef9c61efa95570de3b4fc751a01c2a1d50f44 Mon Sep 17 00:00:00 2001 From: "Mark R. Tuttle" Date: Sun, 18 Apr 2021 20:59:36 +0000 Subject: [PATCH 1/3] Add fat-pointer regression tests --- rust-tests/cbmc-reg/FatPointers/boxslice.rs | 10 ++++++ rust-tests/cbmc-reg/FatPointers/boxtrait.rs | 31 +++++++++++++++++ rust-tests/cbmc-reg/FatPointers/slice1.rs | 6 ++++ rust-tests/cbmc-reg/FatPointers/slice2.rs | 6 ++++ rust-tests/cbmc-reg/FatPointers/slice3.rs | 6 ++++ .../cbmc-reg/FatPointers/structslice.rs | 15 +++++++++ rust-tests/cbmc-reg/FatPointers/trait1.rs | 22 +++++++++++++ rust-tests/cbmc-reg/FatPointers/trait2.rs | 22 +++++++++++++ rust-tests/cbmc-reg/FatPointers/trait3.rs | 31 +++++++++++++++++ .../cbmc-reg/Transparent/transparent1.rs | 6 ++++ .../cbmc-reg/Transparent/transparent2.rs | 33 +++++++++++++++++++ .../cbmc-reg/Transparent/transparent3.rs | 17 ++++++++++ .../cbmc-reg/Transparent/transparent4.rs | 22 +++++++++++++ 13 files changed, 227 insertions(+) create mode 100644 rust-tests/cbmc-reg/FatPointers/boxslice.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/boxtrait.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/slice1.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/slice2.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/slice3.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/structslice.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/trait1.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/trait2.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/trait3.rs create mode 100644 rust-tests/cbmc-reg/Transparent/transparent1.rs create mode 100644 rust-tests/cbmc-reg/Transparent/transparent2.rs create mode 100644 rust-tests/cbmc-reg/Transparent/transparent3.rs create mode 100644 rust-tests/cbmc-reg/Transparent/transparent4.rs diff --git a/rust-tests/cbmc-reg/FatPointers/boxslice.rs b/rust-tests/cbmc-reg/FatPointers/boxslice.rs new file mode 100644 index 000000000000..52a7cd372bdc --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/boxslice.rs @@ -0,0 +1,10 @@ +/// Casts boxed array to boxed slice (example taken from rust documentation) +use std::str; + +fn main() { + // This vector of bytes is used to initialize a Box<[u8; 4]> + let sparkle_heart = vec![240, 159, 146, 150]; + + // This transformer produces a Box<[u8>] + let _sparkle_heart = str::from_utf8(&sparkle_heart); +} diff --git a/rust-tests/cbmc-reg/FatPointers/boxtrait.rs b/rust-tests/cbmc-reg/FatPointers/boxtrait.rs new file mode 100644 index 000000000000..9c1920baf6f7 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/boxtrait.rs @@ -0,0 +1,31 @@ +// This is handled by the box to box case of unsized pointers + +pub trait Trait { + fn increment(&mut self); + fn get(&self) -> u32; +} + +struct Concrete { + pub index: u32, +} + +impl Concrete { + fn new() -> Self { + Concrete { index: 0 } + } +} + +impl Trait for Concrete { + fn increment(&mut self) { + self.index = self.index + 1; + } + fn get(&self) -> u32 { + self.index + } +} + +fn main() { + let mut x: Box = Box::new(Concrete::new()); + x.increment(); + assert!(x.get() == 1); +} diff --git a/rust-tests/cbmc-reg/FatPointers/slice1.rs b/rust-tests/cbmc-reg/FatPointers/slice1.rs new file mode 100644 index 000000000000..808b86a9ca46 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/slice1.rs @@ -0,0 +1,6 @@ +fn main() { + let array = [1, 2, 3, 4, 5, 6]; + let slice: &[u32] = &array; + assert!(slice[0] == 1); + assert!(slice[5] == 6); +} diff --git a/rust-tests/cbmc-reg/FatPointers/slice2.rs b/rust-tests/cbmc-reg/FatPointers/slice2.rs new file mode 100644 index 000000000000..0a18923cfa50 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/slice2.rs @@ -0,0 +1,6 @@ +fn main() { + let array = [1, 2, 3, 4, 5, 6]; + let slice = &array[2..5]; + assert!(slice[0] == 3); + assert!(slice[2] == 5); +} diff --git a/rust-tests/cbmc-reg/FatPointers/slice3.rs b/rust-tests/cbmc-reg/FatPointers/slice3.rs new file mode 100644 index 000000000000..ab51fb062e0b --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/slice3.rs @@ -0,0 +1,6 @@ +fn main() { + let array = [1, 2, 3, 4, 5, 6]; + let slice1 = &array[2..5]; + let slice2 = &slice1[1..2]; + assert!(slice2[0] == 4); +} diff --git a/rust-tests/cbmc-reg/FatPointers/structslice.rs b/rust-tests/cbmc-reg/FatPointers/structslice.rs new file mode 100644 index 000000000000..32f2e4fccbb7 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/structslice.rs @@ -0,0 +1,15 @@ +struct Concrete { + array: [u32; 4], +} + +struct Abstract<'a> { + uints: &'a [u32], +} + +fn main() { + let x = Concrete { array: [1, 2, 3, 4] }; + assert!(x.array[0] == 1); + let y = Abstract { uints: &[10, 11, 12, 13] }; + assert!(y.uints[0] == 10); + assert!(y.uints[3] == 13); +} diff --git a/rust-tests/cbmc-reg/FatPointers/trait1.rs b/rust-tests/cbmc-reg/FatPointers/trait1.rs new file mode 100644 index 000000000000..49fb7cd58249 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/trait1.rs @@ -0,0 +1,22 @@ +/// Cast a concrete ref to a trait ref. + +pub trait Subscriber { + fn process(&mut self); +} + +struct DummySubscriber {} + +impl DummySubscriber { + fn new() -> Self { + DummySubscriber {} + } +} + +impl Subscriber for DummySubscriber { + fn process(&mut self) {} +} + +fn main() { + let _d = DummySubscriber::new(); + let _s = &_d as &dyn Subscriber; +} diff --git a/rust-tests/cbmc-reg/FatPointers/trait2.rs b/rust-tests/cbmc-reg/FatPointers/trait2.rs new file mode 100644 index 000000000000..79e5b2840c72 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/trait2.rs @@ -0,0 +1,22 @@ +/// Cast a concrete ref to a trait raw pointer. + +pub trait Subscriber { + fn process(&mut self); +} + +struct DummySubscriber {} + +impl DummySubscriber { + fn new() -> Self { + DummySubscriber {} + } +} + +impl Subscriber for DummySubscriber { + fn process(&mut self) {} +} + +fn main() { + let _d = DummySubscriber::new(); + let _s = &_d as *const dyn Subscriber; +} diff --git a/rust-tests/cbmc-reg/FatPointers/trait3.rs b/rust-tests/cbmc-reg/FatPointers/trait3.rs new file mode 100644 index 000000000000..9fb099b8a886 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/trait3.rs @@ -0,0 +1,31 @@ +/// Cast a concrete ref to +/// concrete raw pointer +/// trait ref +/// trait raw pointer +/// Cast a trait ref to a trait raw pointer + +pub trait Subscriber { + fn process(&mut self); +} + +struct DummySubscriber {} + +impl DummySubscriber { + fn new() -> Self { + DummySubscriber {} + } +} + +impl Subscriber for DummySubscriber { + fn process(&mut self) {} +} + +fn main() { + let _d = DummySubscriber::new(); + let _d1 = &_d as *const DummySubscriber; + + let _s = &_d as &dyn Subscriber; + let _s1 = &_d as *const dyn Subscriber; + + let _x = _s as *const dyn Subscriber; +} diff --git a/rust-tests/cbmc-reg/Transparent/transparent1.rs b/rust-tests/cbmc-reg/Transparent/transparent1.rs new file mode 100644 index 000000000000..6c52de8b7056 --- /dev/null +++ b/rust-tests/cbmc-reg/Transparent/transparent1.rs @@ -0,0 +1,6 @@ +fn main() { + let mut x: u32 = 4; + let pointer0: std::ptr::NonNull = std::ptr::NonNull::new(&mut x).unwrap(); + let _y = unsafe { *pointer0.as_ptr() }; + assert!(_y == 4); +} diff --git a/rust-tests/cbmc-reg/Transparent/transparent2.rs b/rust-tests/cbmc-reg/Transparent/transparent2.rs new file mode 100644 index 000000000000..5c06bb0e8ceb --- /dev/null +++ b/rust-tests/cbmc-reg/Transparent/transparent2.rs @@ -0,0 +1,33 @@ +#[derive(Clone, Copy)] +struct Target { + x: u32, + y: u32, +} + +struct Container { + ptr: std::ptr::NonNull, +} + +impl Container +where + T: Copy, +{ + fn new(val: &mut T) -> Self { + return Container { ptr: std::ptr::NonNull::new(val).unwrap() }; + } + fn get(&self) -> T { + return unsafe { *self.ptr.as_ptr() }; + } +} + +fn main() { + let mut x: u32 = 4; + let container = Container::new(&mut x); + let _y = container.get(); + assert!(_y == 4); + + let mut target: Target = Target { x: 3, y: 4 }; + let cont = Container::new(&mut target); + assert!((unsafe { *cont.ptr.as_ptr() }).x == 3); + assert!((unsafe { *cont.ptr.as_ptr() }).y == 4); +} diff --git a/rust-tests/cbmc-reg/Transparent/transparent3.rs b/rust-tests/cbmc-reg/Transparent/transparent3.rs new file mode 100644 index 000000000000..c23ea74a9dc9 --- /dev/null +++ b/rust-tests/cbmc-reg/Transparent/transparent3.rs @@ -0,0 +1,17 @@ +//#repr(transparent)] +pub struct Pointer { + pointer: *const T, +} + +pub struct Container { + container: Pointer, +} + +fn main() { + let x: u32 = 4; + let my_pointer = Pointer { pointer: &x }; + let my_container = Container { container: my_pointer }; + + let y: u32 = unsafe { *my_container.container.pointer }; + assert!(y == 4); +} diff --git a/rust-tests/cbmc-reg/Transparent/transparent4.rs b/rust-tests/cbmc-reg/Transparent/transparent4.rs new file mode 100644 index 000000000000..283fc7ce5a18 --- /dev/null +++ b/rust-tests/cbmc-reg/Transparent/transparent4.rs @@ -0,0 +1,22 @@ +#[repr(transparent)] +pub struct Pointer { + pointer: *const T, +} + +#[repr(transparent)] +pub struct Wrapper(T); + +pub struct Container { + container: Pointer, +} + +fn main() { + let x: u32 = 4; + let my_container = Container { container: Pointer { pointer: &x } }; + + let y: u32 = unsafe { *my_container.container.pointer }; + assert!(y == 4); + + let w: Wrapper = Wrapper(4); + // Wrapper is a struct with no fields, there is no way to access the 4 +} From e43609bab88e003a0721c652d2e0fd725728b30e Mon Sep 17 00:00:00 2001 From: "Mark R. Tuttle" Date: Tue, 20 Apr 2021 21:04:11 +0000 Subject: [PATCH 2/3] Respond to code review of fat-pointer regression tests --- rust-tests/cbmc-reg/FatPointers/boxslice.rs | 10 -------- rust-tests/cbmc-reg/FatPointers/boxslice1.rs | 15 ++++++++++++ .../cbmc-reg/FatPointers/boxslice2_fail.rs | 23 +++++++++++++++++++ rust-tests/cbmc-reg/FatPointers/boxtrait.rs | 3 +++ rust-tests/cbmc-reg/FatPointers/slice1.rs | 3 +++ rust-tests/cbmc-reg/FatPointers/slice2.rs | 3 +++ rust-tests/cbmc-reg/FatPointers/slice3.rs | 3 +++ .../cbmc-reg/FatPointers/structslice.rs | 3 +++ rust-tests/cbmc-reg/FatPointers/trait1.rs | 19 +++++++++++---- rust-tests/cbmc-reg/FatPointers/trait2.rs | 19 +++++++++++---- rust-tests/cbmc-reg/FatPointers/trait3.rs | 13 +++++++---- .../cbmc-reg/Transparent/transparent1.rs | 7 ++++-- .../cbmc-reg/Transparent/transparent2.rs | 9 +++++--- .../cbmc-reg/Transparent/transparent3.rs | 5 +++- .../cbmc-reg/Transparent/transparent4.rs | 9 ++++++-- 15 files changed, 111 insertions(+), 33 deletions(-) delete mode 100644 rust-tests/cbmc-reg/FatPointers/boxslice.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/boxslice1.rs create mode 100644 rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs diff --git a/rust-tests/cbmc-reg/FatPointers/boxslice.rs b/rust-tests/cbmc-reg/FatPointers/boxslice.rs deleted file mode 100644 index 52a7cd372bdc..000000000000 --- a/rust-tests/cbmc-reg/FatPointers/boxslice.rs +++ /dev/null @@ -1,10 +0,0 @@ -/// Casts boxed array to boxed slice (example taken from rust documentation) -use std::str; - -fn main() { - // This vector of bytes is used to initialize a Box<[u8; 4]> - let sparkle_heart = vec![240, 159, 146, 150]; - - // This transformer produces a Box<[u8>] - let _sparkle_heart = str::from_utf8(&sparkle_heart); -} diff --git a/rust-tests/cbmc-reg/FatPointers/boxslice1.rs b/rust-tests/cbmc-reg/FatPointers/boxslice1.rs new file mode 100644 index 000000000000..61da693cc879 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/boxslice1.rs @@ -0,0 +1,15 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// Casts boxed array to boxed slice (example taken from rust documentation) +use std::str; + +fn main() { + // This vector of bytes is used to initialize a Box<[u8; 4]> + let sparkle_heart_vec = vec![240, 159, 146, 150]; + + // This transformer produces a Box<[u8>] + let _sparkle_heart_str = str::from_utf8(&sparkle_heart_vec); + + // see boxslice2_fail.rs for an attempt to test sparkle_heart_str +} diff --git a/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs b/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs new file mode 100644 index 000000000000..ca5be4375034 --- /dev/null +++ b/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs @@ -0,0 +1,23 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// Casts boxed array to boxed slice (example taken from rust documentation) +use std::str; + +fn main() { + // This vector of bytes is used to initialize a Box<[u8; 4]> + let sparkle_heart_vec = vec![240, 159, 146, 150]; + + // This transformer produces a Box<[u8>] + let sparkle_heart_str = str::from_utf8(&sparkle_heart_vec); + + // This match statement generates failures even though + // the binary runs without failures. + match sparkle_heart_str { + Ok(string) => match string.bytes().nth(0) { + Some(b) => assert_eq!(b, 240), + _ => assert!(true), + }, + _ => assert!(true), + } +} diff --git a/rust-tests/cbmc-reg/FatPointers/boxtrait.rs b/rust-tests/cbmc-reg/FatPointers/boxtrait.rs index 9c1920baf6f7..13bc7f45be2f 100644 --- a/rust-tests/cbmc-reg/FatPointers/boxtrait.rs +++ b/rust-tests/cbmc-reg/FatPointers/boxtrait.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + // This is handled by the box to box case of unsized pointers pub trait Trait { diff --git a/rust-tests/cbmc-reg/FatPointers/slice1.rs b/rust-tests/cbmc-reg/FatPointers/slice1.rs index 808b86a9ca46..c43a48a76bc1 100644 --- a/rust-tests/cbmc-reg/FatPointers/slice1.rs +++ b/rust-tests/cbmc-reg/FatPointers/slice1.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + fn main() { let array = [1, 2, 3, 4, 5, 6]; let slice: &[u32] = &array; diff --git a/rust-tests/cbmc-reg/FatPointers/slice2.rs b/rust-tests/cbmc-reg/FatPointers/slice2.rs index 0a18923cfa50..569e8ecf4739 100644 --- a/rust-tests/cbmc-reg/FatPointers/slice2.rs +++ b/rust-tests/cbmc-reg/FatPointers/slice2.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + fn main() { let array = [1, 2, 3, 4, 5, 6]; let slice = &array[2..5]; diff --git a/rust-tests/cbmc-reg/FatPointers/slice3.rs b/rust-tests/cbmc-reg/FatPointers/slice3.rs index ab51fb062e0b..5f08278cf019 100644 --- a/rust-tests/cbmc-reg/FatPointers/slice3.rs +++ b/rust-tests/cbmc-reg/FatPointers/slice3.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + fn main() { let array = [1, 2, 3, 4, 5, 6]; let slice1 = &array[2..5]; diff --git a/rust-tests/cbmc-reg/FatPointers/structslice.rs b/rust-tests/cbmc-reg/FatPointers/structslice.rs index 32f2e4fccbb7..d424bd742df2 100644 --- a/rust-tests/cbmc-reg/FatPointers/structslice.rs +++ b/rust-tests/cbmc-reg/FatPointers/structslice.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + struct Concrete { array: [u32; 4], } diff --git a/rust-tests/cbmc-reg/FatPointers/trait1.rs b/rust-tests/cbmc-reg/FatPointers/trait1.rs index 49fb7cd58249..b26907e629a8 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait1.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait1.rs @@ -1,22 +1,31 @@ -/// Cast a concrete ref to a trait ref. +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// Cast a concrete ref to a trait ref. pub trait Subscriber { - fn process(&mut self); + fn process(&self) -> u32; } -struct DummySubscriber {} +struct DummySubscriber { + val: u32, +} impl DummySubscriber { fn new() -> Self { - DummySubscriber {} + DummySubscriber { val: 0 } } } impl Subscriber for DummySubscriber { - fn process(&mut self) {} + fn process(&self) -> u32 { + let DummySubscriber { val: v } = self; + *v + 1 + } } fn main() { let _d = DummySubscriber::new(); let _s = &_d as &dyn Subscriber; + assert_eq!(_s.process(), 1); } diff --git a/rust-tests/cbmc-reg/FatPointers/trait2.rs b/rust-tests/cbmc-reg/FatPointers/trait2.rs index 79e5b2840c72..7cd5556745be 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait2.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait2.rs @@ -1,22 +1,31 @@ -/// Cast a concrete ref to a trait raw pointer. +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// Cast a concrete ref to a trait raw pointer. pub trait Subscriber { - fn process(&mut self); + fn process(&self) -> u32; } -struct DummySubscriber {} +struct DummySubscriber { + val: u32, +} impl DummySubscriber { fn new() -> Self { - DummySubscriber {} + DummySubscriber { val: 0 } } } impl Subscriber for DummySubscriber { - fn process(&mut self) {} + fn process(&self) -> u32 { + let DummySubscriber { val: v } = self; + *v + 1 + } } fn main() { let _d = DummySubscriber::new(); let _s = &_d as *const dyn Subscriber; + assert_eq!(unsafe { _s.as_ref().unwrap().process() }, 1); } diff --git a/rust-tests/cbmc-reg/FatPointers/trait3.rs b/rust-tests/cbmc-reg/FatPointers/trait3.rs index 9fb099b8a886..ebc7ab3cfa5b 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait3.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait3.rs @@ -1,8 +1,11 @@ -/// Cast a concrete ref to -/// concrete raw pointer -/// trait ref -/// trait raw pointer -/// Cast a trait ref to a trait raw pointer +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + +// Cast a concrete ref to +// concrete raw pointer +// trait ref +// trait raw pointer +// Cast a trait ref to a trait raw pointer pub trait Subscriber { fn process(&mut self); diff --git a/rust-tests/cbmc-reg/Transparent/transparent1.rs b/rust-tests/cbmc-reg/Transparent/transparent1.rs index 6c52de8b7056..5b10168a7d52 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent1.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent1.rs @@ -1,6 +1,9 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + fn main() { let mut x: u32 = 4; let pointer0: std::ptr::NonNull = std::ptr::NonNull::new(&mut x).unwrap(); - let _y = unsafe { *pointer0.as_ptr() }; - assert!(_y == 4); + let y = unsafe { *pointer0.as_ptr() }; + assert_eq!(y, 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent2.rs b/rust-tests/cbmc-reg/Transparent/transparent2.rs index 5c06bb0e8ceb..92f71ef72fcb 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent2.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent2.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + #[derive(Clone, Copy)] struct Target { x: u32, @@ -24,10 +27,10 @@ fn main() { let mut x: u32 = 4; let container = Container::new(&mut x); let _y = container.get(); - assert!(_y == 4); + assert_eq!(_y, 4); let mut target: Target = Target { x: 3, y: 4 }; let cont = Container::new(&mut target); - assert!((unsafe { *cont.ptr.as_ptr() }).x == 3); - assert!((unsafe { *cont.ptr.as_ptr() }).y == 4); + assert_eq!((unsafe { *cont.ptr.as_ptr() }).x, 3); + assert_eq!((unsafe { *cont.ptr.as_ptr() }).y, 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent3.rs b/rust-tests/cbmc-reg/Transparent/transparent3.rs index c23ea74a9dc9..dfed5c644c98 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent3.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent3.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + //#repr(transparent)] pub struct Pointer { pointer: *const T, @@ -13,5 +16,5 @@ fn main() { let my_container = Container { container: my_pointer }; let y: u32 = unsafe { *my_container.container.pointer }; - assert!(y == 4); + assert_eq!(y, 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent4.rs b/rust-tests/cbmc-reg/Transparent/transparent4.rs index 283fc7ce5a18..290dd7acea5d 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent4.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent4.rs @@ -1,3 +1,6 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 OR MIT + #[repr(transparent)] pub struct Pointer { pointer: *const T, @@ -15,8 +18,10 @@ fn main() { let my_container = Container { container: Pointer { pointer: &x } }; let y: u32 = unsafe { *my_container.container.pointer }; - assert!(y == 4); + assert_eq!(y, 4); let w: Wrapper = Wrapper(4); - // Wrapper is a struct with no fields, there is no way to access the 4 + + let Wrapper(c) = Wrapper(4); + assert_eq!(c, 4); } From 730040ddd41723095743c6aeef980b8e100a0b7e Mon Sep 17 00:00:00 2001 From: "Mark R. Tuttle" Date: Wed, 21 Apr 2021 23:53:00 +0000 Subject: [PATCH 3/3] Respond to second code review of fat-pointer regression tests --- .../cbmc-reg/FatPointers/boxslice2_fail.rs | 2 +- rust-tests/cbmc-reg/FatPointers/trait1.rs | 2 +- rust-tests/cbmc-reg/FatPointers/trait2.rs | 2 +- rust-tests/cbmc-reg/FatPointers/trait3.rs | 29 +++++++++++++------ .../cbmc-reg/Transparent/transparent1.rs | 2 +- .../cbmc-reg/Transparent/transparent2.rs | 4 +-- .../cbmc-reg/Transparent/transparent3.rs | 2 +- .../cbmc-reg/Transparent/transparent4.rs | 6 ++-- 8 files changed, 30 insertions(+), 19 deletions(-) diff --git a/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs b/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs index ca5be4375034..87a54c8f9316 100644 --- a/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs +++ b/rust-tests/cbmc-reg/FatPointers/boxslice2_fail.rs @@ -15,7 +15,7 @@ fn main() { // the binary runs without failures. match sparkle_heart_str { Ok(string) => match string.bytes().nth(0) { - Some(b) => assert_eq!(b, 240), + Some(b) => assert!(b == 240), _ => assert!(true), }, _ => assert!(true), diff --git a/rust-tests/cbmc-reg/FatPointers/trait1.rs b/rust-tests/cbmc-reg/FatPointers/trait1.rs index b26907e629a8..2eec16094a26 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait1.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait1.rs @@ -27,5 +27,5 @@ impl Subscriber for DummySubscriber { fn main() { let _d = DummySubscriber::new(); let _s = &_d as &dyn Subscriber; - assert_eq!(_s.process(), 1); + assert!(_s.process() == 1); } diff --git a/rust-tests/cbmc-reg/FatPointers/trait2.rs b/rust-tests/cbmc-reg/FatPointers/trait2.rs index 7cd5556745be..2ca1638adb0b 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait2.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait2.rs @@ -27,5 +27,5 @@ impl Subscriber for DummySubscriber { fn main() { let _d = DummySubscriber::new(); let _s = &_d as *const dyn Subscriber; - assert_eq!(unsafe { _s.as_ref().unwrap().process() }, 1); + assert!(unsafe { _s.as_ref().unwrap().process() } == 1); } diff --git a/rust-tests/cbmc-reg/FatPointers/trait3.rs b/rust-tests/cbmc-reg/FatPointers/trait3.rs index ebc7ab3cfa5b..4d9feeb2e443 100644 --- a/rust-tests/cbmc-reg/FatPointers/trait3.rs +++ b/rust-tests/cbmc-reg/FatPointers/trait3.rs @@ -8,27 +8,38 @@ // Cast a trait ref to a trait raw pointer pub trait Subscriber { - fn process(&mut self); + fn process(&self) -> u32; } -struct DummySubscriber {} +struct DummySubscriber { + val: u32, +} impl DummySubscriber { fn new() -> Self { - DummySubscriber {} + DummySubscriber { val: 0 } } } impl Subscriber for DummySubscriber { - fn process(&mut self) {} + fn process(&self) -> u32 { + let DummySubscriber { val: v } = self; + *v + 1 + } } fn main() { - let _d = DummySubscriber::new(); - let _d1 = &_d as *const DummySubscriber; + let d = DummySubscriber::new(); + + let d1 = &d as *const DummySubscriber; + assert!(unsafe { d1.as_ref().unwrap().process() } == 1); + + let s = &d as &dyn Subscriber; + assert!(s.process() == 1); - let _s = &_d as &dyn Subscriber; - let _s1 = &_d as *const dyn Subscriber; + let s1 = &d as *const dyn Subscriber; + assert!(unsafe { s1.as_ref().unwrap().process() } == 1); - let _x = _s as *const dyn Subscriber; + let x = s as *const dyn Subscriber; + assert!(unsafe { x.as_ref().unwrap().process() } == 1); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent1.rs b/rust-tests/cbmc-reg/Transparent/transparent1.rs index 5b10168a7d52..96386187c4ad 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent1.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent1.rs @@ -5,5 +5,5 @@ fn main() { let mut x: u32 = 4; let pointer0: std::ptr::NonNull = std::ptr::NonNull::new(&mut x).unwrap(); let y = unsafe { *pointer0.as_ptr() }; - assert_eq!(y, 4); + assert!(y == 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent2.rs b/rust-tests/cbmc-reg/Transparent/transparent2.rs index 92f71ef72fcb..d872cad4ccdf 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent2.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent2.rs @@ -31,6 +31,6 @@ fn main() { let mut target: Target = Target { x: 3, y: 4 }; let cont = Container::new(&mut target); - assert_eq!((unsafe { *cont.ptr.as_ptr() }).x, 3); - assert_eq!((unsafe { *cont.ptr.as_ptr() }).y, 4); + assert!((unsafe { *cont.ptr.as_ptr() }).x == 3); + assert!((unsafe { *cont.ptr.as_ptr() }).y == 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent3.rs b/rust-tests/cbmc-reg/Transparent/transparent3.rs index dfed5c644c98..7d342118bdeb 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent3.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent3.rs @@ -16,5 +16,5 @@ fn main() { let my_container = Container { container: my_pointer }; let y: u32 = unsafe { *my_container.container.pointer }; - assert_eq!(y, 4); + assert!(y == 4); } diff --git a/rust-tests/cbmc-reg/Transparent/transparent4.rs b/rust-tests/cbmc-reg/Transparent/transparent4.rs index 290dd7acea5d..96c1916858c5 100644 --- a/rust-tests/cbmc-reg/Transparent/transparent4.rs +++ b/rust-tests/cbmc-reg/Transparent/transparent4.rs @@ -18,10 +18,10 @@ fn main() { let my_container = Container { container: Pointer { pointer: &x } }; let y: u32 = unsafe { *my_container.container.pointer }; - assert_eq!(y, 4); + assert!(y == 4); let w: Wrapper = Wrapper(4); - let Wrapper(c) = Wrapper(4); - assert_eq!(c, 4); + let Wrapper(c) = w; + assert!(c == 4); }