Skip to content

Commit e7e1674

Browse files
joshlfjoshlf
committed
[derive] Refactor is_bit_valid tests
gherrit-pr-id: G0d92654de6e9a8c16ac830e35adf298a1b486df4
1 parent b6642a7 commit e7e1674

3 files changed

Lines changed: 43 additions & 156 deletions

File tree

‎zerocopy-derive/tests/include.rs‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -128,4 +128,24 @@ pub mod util {
128128
let ptr = ptr.cast::<_, ::zerocopy::pointer::cast::CastSized, _>();
129129
assert!(<T as super::imp::TryFromBytes>::is_bit_valid(ptr));
130130
}
131+
132+
pub fn test_is_bit_valid<T: super::imp::TryFromBytes>(
133+
mut val: impl super::imp::IntoBytes,
134+
is_bit_valid: bool,
135+
) {
136+
let candidate = ::zerocopy::Ptr::from_mut(&mut val);
137+
let candidate = candidate.forget_aligned();
138+
// SAFETY: by `val: impl IntoBytes`, `val` consists entirely of
139+
// initialized bytes. It's still unsound because this might let us
140+
// overwrite `val` with initialized-but-invalid bytes, but we don't do
141+
// that, so no UB is ever exercised.
142+
let candidate = unsafe { candidate.assume_initialized() };
143+
144+
let mut candidate = {
145+
use super::imp::pointer::{cast::CastSized, BecauseExclusive};
146+
candidate.cast::<super::imp::ReadOnly<T>, CastSized, (_, BecauseExclusive)>()
147+
};
148+
149+
super::imp::assert_eq!(T::is_bit_valid(candidate.reborrow_shared()), is_bit_valid);
150+
}
131151
}

‎zerocopy-derive/tests/struct_try_from_bytes.rs‎

Lines changed: 13 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -17,18 +17,10 @@ include!("include.rs");
1717

1818
#[test]
1919
fn zst() {
20-
use imp::From;
21-
22-
// FIXME(#5): Use `try_transmute` in this test once it's available.
23-
let candidate = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&(())));
24-
let candidate = candidate.forget_aligned();
25-
// SAFETY: `&()` trivially consists entirely of initialized bytes.
26-
let candidate = unsafe { candidate.assume_initialized() };
27-
let is_bit_valid = <() as imp::TryFromBytes>::is_bit_valid(candidate);
28-
imp::assert!(is_bit_valid);
20+
crate::util::test_is_bit_valid::<()>((), true);
2921
}
3022

31-
#[derive(imp::TryFromBytes, imp::Immutable)]
23+
#[derive(imp::TryFromBytes, imp::Immutable, imp::IntoBytes)]
3224
#[repr(C)]
3325
struct One {
3426
a: u8,
@@ -38,18 +30,11 @@ util_assert_impl_all!(One: imp::TryFromBytes);
3830

3931
#[test]
4032
fn one() {
41-
use imp::From;
42-
43-
// FIXME(#5): Use `try_transmute` in this test once it's available.
44-
let candidate = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&One { a: 42 }));
45-
let candidate = candidate.forget_aligned();
46-
// SAFETY: `&One` consists entirely of initialized bytes.
47-
let candidate = unsafe { candidate.assume_initialized() };
48-
let is_bit_valid = <One as imp::TryFromBytes>::is_bit_valid(candidate);
49-
imp::assert!(is_bit_valid);
33+
crate::util::test_is_bit_valid::<One>(One { a: 42 }, true);
34+
crate::util::test_is_bit_valid::<One>(One { a: 43 }, true);
5035
}
5136

52-
#[derive(imp::TryFromBytes, imp::Immutable)]
37+
#[derive(imp::TryFromBytes, imp::Immutable, imp::IntoBytes)]
5338
#[repr(C)]
5439
struct Two {
5540
a: bool,
@@ -60,36 +45,9 @@ util_assert_impl_all!(Two: imp::TryFromBytes);
6045

6146
#[test]
6247
fn two() {
63-
use imp::From;
64-
65-
// FIXME(#5): Use `try_transmute` in this test once it's available.
66-
let candidate = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&Two { a: false, b: () }));
67-
let candidate = candidate.forget_aligned();
68-
// SAFETY: `&Two` consists entirely of initialized bytes.
69-
let candidate = unsafe { candidate.assume_initialized() };
70-
let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate);
71-
imp::assert!(is_bit_valid);
72-
}
73-
74-
#[test]
75-
fn two_bad() {
76-
// FIXME(#5): Use `try_transmute` in this test once it's available.
77-
let mut buf = [2u8; 1];
78-
let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
79-
let candidate = candidate.forget_aligned();
80-
// SAFETY: `&Two` consists entirely of initialized bytes.
81-
let candidate = unsafe { candidate.assume_initialized() };
82-
83-
let candidate = {
84-
use imp::pointer::{cast::CastSized, BecauseExclusive};
85-
candidate.cast::<_, CastSized, (_, BecauseExclusive)>()
86-
};
87-
88-
// SAFETY: `candidate`'s referent is as-initialized as `Two`.
89-
let mut candidate = unsafe { candidate.assume_initialized() };
90-
91-
let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
92-
imp::assert!(!is_bit_valid);
48+
crate::util::test_is_bit_valid::<Two>(Two { a: false, b: () }, true);
49+
crate::util::test_is_bit_valid::<Two>(Two { a: true, b: () }, true);
50+
crate::util::test_is_bit_valid::<Two>([2u8], false);
9351
}
9452

9553
#[derive(imp::KnownLayout, imp::TryFromBytes)]
@@ -105,17 +63,14 @@ fn un_sized() {
10563
// FIXME(#5): Use `try_transmute` in this test once it's available.
10664
let mut buf = [16u8, 12, 42];
10765
let candidate = ::zerocopy::Ptr::from_mut(&mut buf[..]);
108-
let candidate = candidate.forget_aligned();
10966
// SAFETY: `&Unsized` consists entirely of initialized bytes.
11067
let candidate = unsafe { candidate.assume_initialized() };
11168

112-
let candidate = {
69+
let mut candidate = {
11370
use imp::pointer::{cast::CastUnsized, BecauseExclusive};
11471
candidate.cast::<_, CastUnsized, (_, BecauseExclusive)>()
11572
};
11673

117-
// SAFETY: `candidate`'s referent is as-initialized as `Two`.
118-
let mut candidate = unsafe { candidate.assume_initialized() };
11974
let is_bit_valid = <Unsized as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
12075
imp::assert!(is_bit_valid);
12176
}
@@ -151,7 +106,7 @@ where
151106

152107
util_assert_impl_all!(WithParams<'static, 'static, u8, 42>: imp::TryFromBytes);
153108

154-
#[derive(imp::FromBytes)]
109+
#[derive(imp::FromBytes, imp::IntoBytes)]
155110
#[repr(C)]
156111
struct MaybeFromBytes<T>(T);
157112

@@ -161,23 +116,9 @@ fn test_maybe_from_bytes() {
161116
// trivial `is_bit_valid` impl that always returns true. This test confirms
162117
// that we *don't* spuriously do that when generic parameters are present.
163118

164-
let mut buf = [2u8];
165-
let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
166-
let candidate = candidate.bikeshed_recall_initialized_from_bytes();
167-
168-
let candidate = {
169-
use imp::pointer::{cast::CastSized, BecauseExclusive};
170-
candidate.cast::<MaybeFromBytes<bool>, CastSized, (_, BecauseExclusive)>()
171-
};
172-
173-
// SAFETY: `[u8]` consists entirely of initialized bytes.
174-
let candidate = unsafe { candidate.assume_initialized() };
175-
let mut candidate =
176-
candidate.cast::<_, imp::pointer::cast::CastSized, (_, imp::pointer::BecauseExclusive)>();
177-
178-
let is_bit_valid =
179-
<MaybeFromBytes<bool> as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
180-
imp::assert!(!is_bit_valid);
119+
crate::util::test_is_bit_valid::<MaybeFromBytes<bool>>(MaybeFromBytes(false), true);
120+
crate::util::test_is_bit_valid::<MaybeFromBytes<bool>>(MaybeFromBytes(true), true);
121+
crate::util::test_is_bit_valid::<MaybeFromBytes<bool>>([2u8], false);
181122
}
182123

183124
#[derive(Debug, PartialEq, Eq, imp::TryFromBytes, imp::Immutable, imp::KnownLayout)]

‎zerocopy-derive/tests/union_try_from_bytes.rs‎

Lines changed: 10 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -24,18 +24,11 @@ util_assert_impl_all!(One: imp::TryFromBytes);
2424

2525
#[test]
2626
fn one() {
27-
use imp::From;
28-
29-
// FIXME(#5): Use `try_transmute` in this test once it's available.
30-
let candidate = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&One { a: 42 }));
31-
let candidate = candidate.forget_aligned();
32-
// SAFETY: `&One` consists entirely of initialized bytes.
33-
let candidate = unsafe { candidate.assume_initialized() };
34-
let is_bit_valid = <One as imp::TryFromBytes>::is_bit_valid(candidate);
35-
assert!(is_bit_valid);
27+
crate::util::test_is_bit_valid::<One>([42u8], true);
28+
crate::util::test_is_bit_valid::<One>([43u8], true);
3629
}
3730

38-
#[derive(imp::Immutable, imp::TryFromBytes)]
31+
#[derive(imp::Immutable, imp::TryFromBytes, imp::IntoBytes)]
3932
#[repr(C)]
4033
union Two {
4134
a: bool,
@@ -46,45 +39,9 @@ util_assert_impl_all!(Two: imp::TryFromBytes);
4639

4740
#[test]
4841
fn two() {
49-
use imp::From;
50-
51-
// FIXME(#5): Use `try_transmute` in this test once it's available.
52-
let candidate_a = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&Two { a: false }));
53-
let candidate_a = candidate_a.forget_aligned();
54-
// SAFETY: `&Two` consists entirely of initialized bytes.
55-
let candidate_a = unsafe { candidate_a.assume_initialized() };
56-
let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate_a);
57-
assert!(is_bit_valid);
58-
59-
let candidate_b = ::zerocopy::Ptr::from_ref(<&imp::ReadOnly<_>>::from(&Two { b: true }));
60-
let candidate_b = candidate_b.forget_aligned();
61-
// SAFETY: `&Two` consists entirely of initialized bytes.
62-
let candidate_b = unsafe { candidate_b.assume_initialized() };
63-
let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate_b);
64-
assert!(is_bit_valid);
65-
}
66-
67-
#[test]
68-
fn two_bad() {
69-
// FIXME(#5): Use `try_transmute` in this test once it's available.
70-
let mut buf = [2u8];
71-
let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
72-
let candidate = candidate.forget_aligned();
73-
// SAFETY: `&[u8]` consists entirely of initialized bytes.
74-
let candidate = unsafe { candidate.assume_initialized() };
75-
76-
let candidate = {
77-
use imp::pointer::{cast::CastSized, BecauseExclusive};
78-
candidate.cast::<Two, CastSized, (_, BecauseExclusive)>()
79-
};
80-
81-
// SAFETY: `candidate`'s referent is as-initialized as `Two`.
82-
let candidate = unsafe { candidate.assume_initialized() };
83-
let mut candidate =
84-
candidate.cast::<_, imp::pointer::cast::CastSized, (_, imp::pointer::BecauseExclusive)>();
85-
86-
let is_bit_valid = <Two as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
87-
assert!(!is_bit_valid);
42+
crate::util::test_is_bit_valid::<Two>(Two { a: false }, true);
43+
crate::util::test_is_bit_valid::<Two>(Two { b: true }, true);
44+
crate::util::test_is_bit_valid::<Two>([2u8], false);
8845
}
8946

9047
#[derive(imp::Immutable, imp::TryFromBytes)]
@@ -96,25 +53,9 @@ union BoolAndZst {
9653

9754
#[test]
9855
fn bool_and_zst() {
99-
// FIXME(#5): Use `try_transmute` in this test once it's available.
100-
let mut buf = [2u8];
101-
let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
102-
let candidate = candidate.forget_aligned();
103-
// SAFETY: `&[u8]` consists entirely of initialized bytes.
104-
let candidate = unsafe { candidate.assume_initialized() };
105-
106-
let candidate = {
107-
use imp::pointer::{cast::CastSized, BecauseExclusive};
108-
candidate.cast::<BoolAndZst, CastSized, (_, BecauseExclusive)>()
109-
};
110-
111-
// SAFETY: `candidate`'s referent is fully initialized.
112-
let candidate = unsafe { candidate.assume_initialized() };
113-
let mut candidate =
114-
candidate.cast::<_, imp::pointer::cast::CastSized, (_, imp::pointer::BecauseExclusive)>();
115-
116-
let is_bit_valid = <BoolAndZst as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
117-
assert!(is_bit_valid);
56+
crate::util::test_is_bit_valid::<BoolAndZst>([0u8], true);
57+
crate::util::test_is_bit_valid::<BoolAndZst>([1u8], true);
58+
crate::util::test_is_bit_valid::<BoolAndZst>([2u8], true);
11859
}
11960

12061
#[derive(imp::FromBytes)]
@@ -129,22 +70,7 @@ fn test_maybe_from_bytes() {
12970
// trivial `is_bit_valid` impl that always returns true. This test confirms
13071
// that we *don't* spuriously do that when generic parameters are present.
13172

132-
let mut buf = [2u8];
133-
let candidate = ::zerocopy::Ptr::from_mut(&mut buf);
134-
let candidate = candidate.bikeshed_recall_initialized_from_bytes();
135-
136-
let candidate = {
137-
use imp::pointer::{cast::CastSized, BecauseExclusive};
138-
candidate.cast::<MaybeFromBytes<bool>, CastSized, (_, BecauseExclusive)>()
139-
};
140-
141-
// SAFETY: `[u8]` consists entirely of initialized bytes.
142-
let candidate = unsafe { candidate.assume_initialized() };
143-
let mut candidate =
144-
candidate.cast::<_, imp::pointer::cast::CastSized, (_, imp::pointer::BecauseExclusive)>();
145-
let is_bit_valid =
146-
<MaybeFromBytes<bool> as imp::TryFromBytes>::is_bit_valid(candidate.reborrow_shared());
147-
imp::assert!(!is_bit_valid);
73+
crate::util::test_is_bit_valid::<MaybeFromBytes<bool>>([2u8], false);
14874
}
14975

15076
#[derive(imp::Immutable, imp::TryFromBytes)]

0 commit comments

Comments
 (0)