use std::fmt;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::task::{Wake, Waker};
use aws_sdk_s3::types::CompletedPart;
use smallvec::SmallVec;
use crate::io::part_reader::{NextPartFuture, PartReader};
use crate::io::{InputStream, PartData, SizeHint};
use crate::model::{ChecksumAlgorithm, ChecksumType};
#[cfg(test)]
use crate::operation::upload::observability::MultipartTransferSummary;
use crate::operation::upload::observability::{
SourceReadObservation, UploadExecutionState, UploadObservability, UploadPartTiming,
UploadStateSnapshot,
};
use crate::operation::upload::{UploadInput, UploadOutputBuilder};
use crate::transfer::{PendingCategory, PendingCause};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum PartTransferPendingReason {
SourceUnavailable,
DispatchClosed,
NoReadyPart,
}
impl From<PartTransferPendingReason> for PendingCause {
fn from(reason: PartTransferPendingReason) -> Self {
match reason {
PartTransferPendingReason::SourceUnavailable => {
Self::new(PendingCategory::Source, "source_unavailable")
}
PartTransferPendingReason::DispatchClosed => Self::in_flight_work("part_completion"),
PartTransferPendingReason::NoReadyPart => Self::in_flight_work("part_work"),
}
}
}
#[derive(Debug)]
pub(crate) enum PartPlan {
Known {
total_parts: u64,
declared_object_size: u64,
},
UntilEof { size_hint: SizeHint },
}
impl PartPlan {
fn all_dispatched(&self, parts_dispatched: u64, eof: bool) -> bool {
match self {
Self::Known { total_parts, .. } => parts_dispatched >= *total_parts,
Self::UntilEof { .. } => eof,
}
}
pub(crate) fn reads_until_eof(&self) -> bool {
matches!(self, Self::UntilEof { .. })
}
fn source_size_hint(&self) -> SizeHint {
match self {
Self::Known {
declared_object_size,
..
} => SizeHint::exact(*declared_object_size),
Self::UntilEof { size_hint } => *size_hint,
}
}
fn validate_progress(&self, actual: u64) -> Result<(), SizeHintViolation> {
if let Some(upper) = self.source_size_hint().upper() {
if actual > upper {
return Err(SizeHintViolation::AboveUpper { actual, upper });
}
}
Ok(())
}
fn validate_complete(&self, actual: u64) -> Result<(), SizeHintViolation> {
self.validate_progress(actual)?;
let lower = self.source_size_hint().lower();
if actual < lower {
return Err(SizeHintViolation::BelowLower { actual, lower });
}
Ok(())
}
pub(crate) fn mpu_object_size(&self, bytes_read: u64) -> Result<u64, SizeHintViolation> {
self.validate_complete(bytes_read)?;
let size_hint = self.source_size_hint();
if size_hint.upper() == Some(size_hint.lower()) {
Ok(size_hint.lower())
} else {
Ok(bytes_read)
}
}
}
#[derive(Debug)]
pub(crate) enum SizeHintViolation {
InvalidBounds { lower: u64, upper: u64 },
BelowLower { actual: u64, lower: u64 },
AboveUpper { actual: u64, upper: u64 },
}
impl fmt::Display for SizeHintViolation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidBounds { lower, upper } => write!(
formatter,
"upload stream lower size bound {lower} exceeds upper bound {upper}"
),
Self::BelowLower { actual, lower } => write!(
formatter,
"upload stream ended after {actual} bytes, below its declared lower bound of \
{lower} bytes"
),
Self::AboveUpper { actual, upper } => write!(
formatter,
"upload stream produced {actual} bytes, exceeding its declared upper bound of \
{upper} bytes"
),
}
}
}
impl std::error::Error for SizeHintViolation {}
#[derive(Debug)]
pub(crate) enum ContentLengthViolation {
Negative { content_length: i64 },
OutsideBounds {
content_length: u64,
lower: u64,
upper: Option<u64>,
},
}
impl fmt::Display for ContentLengthViolation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Negative { content_length } => write!(
formatter,
"upload content_length {content_length} is negative"
),
Self::OutsideBounds {
content_length,
lower,
upper: Some(upper),
} if lower == upper => write!(
formatter,
"upload content_length {content_length} does not match the body's size of \
{lower} bytes"
),
Self::OutsideBounds {
content_length,
lower,
upper: Some(upper),
} => write!(
formatter,
"upload content_length {content_length} is outside the body's size bounds of \
{lower} to {upper} bytes"
),
Self::OutsideBounds {
content_length,
lower,
upper: None,
} => write!(
formatter,
"upload content_length {content_length} is below the body's lower size bound of \
{lower} bytes"
),
}
}
}
impl std::error::Error for ContentLengthViolation {}
const MAX_PART_NUMBER: u64 = 10_000;
#[derive(Debug)]
pub(crate) enum PartNumberViolation {
OutsideRange { part_number: u64 },
Repeated { part_number: u64 },
}
impl fmt::Display for PartNumberViolation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::OutsideRange { part_number } => write!(
formatter,
"upload stream produced part number {part_number}, outside the range 1 to the \
maximum of {MAX_PART_NUMBER} parts; number parts from 1 to {MAX_PART_NUMBER}, \
and combine source data into fewer, larger parts if there are more"
),
Self::Repeated { part_number } => write!(
formatter,
"upload stream produced part number {part_number} more than once"
),
}
}
}
impl std::error::Error for PartNumberViolation {}
pub(crate) fn validate_part_number(part_number: u64) -> Result<(), PartNumberViolation> {
if part_number == 0 || part_number > MAX_PART_NUMBER {
return Err(PartNumberViolation::OutsideRange { part_number });
}
Ok(())
}
pub(crate) fn validate_distinct_part_numbers(
parts: &[CompletedPart],
) -> Result<(), PartNumberViolation> {
for pair in parts.windows(2) {
if pair[0].part_number() == pair[1].part_number() {
return Err(PartNumberViolation::Repeated {
part_number: pair[0].part_number().unwrap_or_default() as u64,
});
}
}
Ok(())
}
pub(crate) fn validate_size_hint(size_hint: SizeHint) -> Result<(), SizeHintViolation> {
if let Some(upper) = size_hint.upper() {
if size_hint.lower() > upper {
return Err(SizeHintViolation::InvalidBounds {
lower: size_hint.lower(),
upper,
});
}
}
Ok(())
}
#[derive(Debug)]
pub(crate) enum UploadChecksumViolation {
ContentMd5WithMultipart,
CompositeExpectedValueWithMultipart { algorithm: ChecksumAlgorithm },
PartChecksumWithoutStrategy { part_number: u64 },
}
impl fmt::Display for UploadChecksumViolation {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ContentMd5WithMultipart => write!(
formatter,
"upload content_md5 is not supported for multipart uploads; use a \
ChecksumStrategy to verify the upload, or keep the object below the multipart \
threshold"
),
Self::CompositeExpectedValueWithMultipart { algorithm } => match algorithm {
ChecksumAlgorithm::Crc32 | ChecksumAlgorithm::Crc32C => write!(
formatter,
"a composite `{algorithm}` ChecksumStrategy's expected value cannot be sent \
by a multipart upload; use `ChecksumStrategy::full_object` with the same \
expected value"
),
_ => write!(
formatter,
"a `{algorithm}` expected value can only be sent by a single-request upload, \
and this upload is sent as a multipart upload; a single-request upload needs \
a body of known size below the multipart threshold that is not a PartStream"
),
},
Self::PartChecksumWithoutStrategy { part_number } => write!(
formatter,
"upload stream supplied a checksum for part {part_number}, but the upload has no \
ChecksumStrategy to name its algorithm; set a ChecksumStrategy or omit the part \
checksum"
),
}
}
}
impl std::error::Error for UploadChecksumViolation {}
pub(crate) fn validate_content_md5_for_multipart(
upload_input: &UploadInput,
) -> Result<(), UploadChecksumViolation> {
if upload_input.content_md5.is_some() {
return Err(UploadChecksumViolation::ContentMd5WithMultipart);
}
Ok(())
}
pub(crate) fn validate_composite_expected_value_for_multipart(
upload_input: &UploadInput,
) -> Result<(), UploadChecksumViolation> {
if let Some(strategy) = &upload_input.checksum_strategy {
if strategy.multipart_checksum_type() == &ChecksumType::Composite
&& strategy.expected_value().is_some()
{
return Err(
UploadChecksumViolation::CompositeExpectedValueWithMultipart {
algorithm: strategy.algorithm().clone(),
},
);
}
}
Ok(())
}
pub(crate) fn validate_part_checksum_has_strategy(
upload_input: &UploadInput,
part: &PartData,
) -> Result<(), UploadChecksumViolation> {
if part.checksum.is_some() && upload_input.checksum_strategy.is_none() {
return Err(UploadChecksumViolation::PartChecksumWithoutStrategy {
part_number: part.part_number,
});
}
Ok(())
}
pub(crate) fn apply_content_length(
size_hint: SizeHint,
content_length: Option<i64>,
) -> Result<SizeHint, ContentLengthViolation> {
let Some(content_length) = content_length else {
return Ok(size_hint);
};
let declared = u64::try_from(content_length)
.map_err(|_| ContentLengthViolation::Negative { content_length })?;
let within_upper = size_hint.upper().is_none_or(|upper| declared <= upper);
if declared < size_hint.lower() || !within_upper {
return Err(ContentLengthViolation::OutsideBounds {
content_length: declared,
lower: size_hint.lower(),
upper: size_hint.upper(),
});
}
Ok(SizeHint::exact(declared))
}
pub(crate) struct PartReadWake {
notified: AtomicBool,
scheduler: Waker,
}
impl PartReadWake {
pub(crate) fn new(scheduler: Waker) -> Arc<Self> {
Arc::new(Self {
notified: AtomicBool::new(false),
scheduler,
})
}
fn take_notification(&self) -> bool {
self.notified.swap(false, Ordering::AcqRel)
}
pub(crate) fn requeue_if_notified(&self) {
if self.notified.load(Ordering::Acquire) {
self.scheduler.wake_by_ref();
}
}
}
impl Wake for PartReadWake {
fn wake(self: Arc<Self>) {
self.wake_by_ref();
}
fn wake_by_ref(self: &Arc<Self>) {
self.notified.store(true, Ordering::Release);
self.scheduler.wake_by_ref();
}
}
impl std::fmt::Debug for PartReadWake {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("PartReadWake")
.field("notified", &self.notified.load(Ordering::Acquire))
.finish_non_exhaustive()
}
}
#[derive(Debug)]
pub(crate) struct PendingPartRead {
pub(crate) future: NextPartFuture,
pub(crate) wake: Arc<PartReadWake>,
pub(crate) timing: UploadPartTiming,
}
#[derive(Debug, Default)]
struct PendingPartReads {
entries: SmallVec<[PendingPartRead; 4]>,
}
impl PendingPartReads {
fn push(&mut self, read: PendingPartRead) {
self.entries.push(read);
}
fn take_notified(&mut self) -> Option<PendingPartRead> {
let index = self
.entries
.iter()
.position(|read| read.wake.take_notification())?;
Some(self.entries.remove(index))
}
fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
#[derive(Debug)]
pub(crate) struct UploadPartWork {
pending_read: Option<PendingPartRead>,
timing: Option<UploadPartTiming>,
kind: UploadPartWorkKind,
}
#[derive(Debug)]
enum UploadPartWorkKind {
SourceRead,
EmptyObject,
}
impl UploadPartWork {
fn fresh(timing: UploadPartTiming) -> Self {
Self {
pending_read: None,
timing: Some(timing),
kind: UploadPartWorkKind::SourceRead,
}
}
fn resumed(read: PendingPartRead) -> Self {
Self {
pending_read: Some(read),
timing: None,
kind: UploadPartWorkKind::SourceRead,
}
}
fn empty_object(timing: UploadPartTiming) -> Self {
Self {
pending_read: None,
timing: Some(timing),
kind: UploadPartWorkKind::EmptyObject,
}
}
pub(crate) fn take_pending_read(&mut self) -> Option<PendingPartRead> {
self.pending_read.take()
}
pub(crate) fn take_timing(&mut self) -> UploadPartTiming {
self.timing
.take()
.expect("fresh upload work should retain diagnostic timing")
}
pub(crate) fn is_resumed(&self) -> bool {
self.pending_read.is_some()
}
pub(crate) fn is_empty_object(&self) -> bool {
matches!(self.kind, UploadPartWorkKind::EmptyObject)
}
}
#[derive(Debug)]
pub(crate) struct PartTransferState {
pub(crate) part_reader: Arc<PartReader>,
plan: PartPlan,
parts_dispatched: u64,
eof: bool,
parts_in_flight: usize,
pending_reads: PendingPartReads,
completed_parts: Vec<CompletedPart>,
parts_read: u64,
bytes_read: u64,
bytes_uploaded: u64,
observability: UploadObservability,
}
impl PartTransferState {
pub(crate) fn new(
part_reader: Arc<PartReader>,
plan: PartPlan,
completed_parts_capacity: usize,
observability: UploadObservability,
) -> Self {
Self {
part_reader,
plan,
parts_dispatched: 0,
eof: false,
parts_in_flight: 0,
pending_reads: PendingPartReads::default(),
completed_parts: Vec::with_capacity(completed_parts_capacity),
parts_read: 0,
bytes_read: 0,
bytes_uploaded: 0,
observability,
}
}
pub(crate) fn schedule_part(&mut self) -> Option<UploadPartWork> {
if let Some(read) = self.pending_reads.take_notified() {
return Some(UploadPartWork::resumed(read));
}
if self.part_reader.source_unavailable()
|| self.plan.all_dispatched(self.parts_dispatched, self.eof)
{
return None;
}
self.parts_dispatched = self
.parts_dispatched
.checked_add(1)
.expect("multipart dispatch count overflow");
self.parts_in_flight = self
.parts_in_flight
.checked_add(1)
.expect("multipart in-flight count overflow");
self.record_dispatch_closed();
Some(UploadPartWork::fresh(self.observability.part_scheduled()))
}
pub(crate) fn retract_scheduled_part(&mut self) {
self.parts_dispatched = self
.parts_dispatched
.checked_sub(1)
.expect("retracted multipart dispatch underflow");
self.parts_in_flight = self
.parts_in_flight
.checked_sub(1)
.expect("retracted multipart in-flight underflow");
self.record_dispatch_closed();
}
pub(crate) fn park_read(&mut self, read: PendingPartRead) {
self.pending_reads.push(read);
}
pub(crate) fn record_read_pending(&mut self, timing: &mut UploadPartTiming) {
self.observability.record_read_pending(timing);
}
pub(crate) fn begin_upload(
&mut self,
presentation_segments: usize,
timing: UploadPartTiming,
) -> SourceReadObservation {
self.observability
.begin_upload(presentation_segments, timing)
}
pub(crate) fn observe_part(&mut self, bytes: u64) -> Result<u64, SizeHintViolation> {
self.parts_read = self
.parts_read
.checked_add(1)
.expect("source part count overflow");
self.bytes_read = self
.bytes_read
.checked_add(bytes)
.expect("source byte count overflow");
self.plan.validate_progress(self.bytes_read)?;
Ok(self.parts_read)
}
pub(crate) fn record_end_of_stream(&mut self) -> bool {
if self.eof {
return false;
}
self.eof = true;
self.record_dispatch_closed();
true
}
pub(crate) fn finish_read_without_part(&mut self) -> bool {
self.parts_in_flight = self
.parts_in_flight
.checked_sub(1)
.expect("multipart in-flight completion underflow");
self.needs_empty_object_part()
}
pub(crate) fn complete_part(&mut self, part: CompletedPart, bytes_uploaded: u64) {
self.completed_parts.push(part);
self.bytes_uploaded = self
.bytes_uploaded
.checked_add(bytes_uploaded)
.expect("uploaded byte count overflow");
self.parts_in_flight = self
.parts_in_flight
.checked_sub(1)
.expect("multipart in-flight completion underflow");
self.observability.complete_upload();
}
pub(crate) fn reads_until_eof(&self) -> bool {
self.plan.reads_until_eof()
}
fn source_drained(&self) -> bool {
self.plan.all_dispatched(self.parts_dispatched, self.eof)
&& self.parts_in_flight == 0
&& self.pending_reads.is_empty()
}
fn needs_empty_object_part(&self) -> bool {
let source_returned_no_parts = self.parts_read == 0;
let no_part_was_already_uploaded = self.completed_parts.is_empty();
let empty_satisfies_size_hint = self.plan.source_size_hint().lower() == 0;
self.source_drained()
&& source_returned_no_parts
&& no_part_was_already_uploaded
&& empty_satisfies_size_hint
}
pub(crate) fn maybe_start_empty_object_part(&mut self) -> Option<UploadPartWork> {
if !self.needs_empty_object_part() {
return None;
}
self.parts_dispatched = self
.parts_dispatched
.checked_add(1)
.expect("multipart dispatch count overflow");
self.parts_in_flight = self
.parts_in_flight
.checked_add(1)
.expect("multipart in-flight count overflow");
self.record_dispatch_closed();
Some(UploadPartWork::empty_object(
self.observability.part_scheduled(),
))
}
pub(crate) fn is_complete(&self) -> bool {
self.source_drained() && !self.needs_empty_object_part()
}
pub(crate) fn into_completion(self) -> MultipartCompletion {
assert!(
self.is_complete(),
"multipart state completed while work remained"
);
assert_eq!(
self.bytes_read, self.bytes_uploaded,
"multipart completion lost or duplicated source bytes"
);
let final_snapshot = self.snapshot();
self.observability.finish_body();
MultipartCompletion {
part_reader: self.part_reader,
plan: self.plan,
completed_parts: self.completed_parts,
bytes_read: self.bytes_read,
final_snapshot,
}
}
pub(crate) fn snapshot(&self) -> UploadStateSnapshot {
UploadStateSnapshot {
state: UploadExecutionState::Transferring,
parts_dispatched: self.parts_dispatched,
parts_in_flight: self.parts_in_flight,
uploads_in_flight: self.observability.uploads_in_flight(),
pending_reads: self.pending_reads.entries.len(),
completed_parts: self.completed_parts.len(),
bytes_read: self.bytes_read,
bytes_uploaded: self.bytes_uploaded,
eof: self.eof,
dispatch_closed: self.plan.all_dispatched(self.parts_dispatched, self.eof),
}
}
pub(crate) fn pending_reason(&self) -> PartTransferPendingReason {
if self.part_reader.source_unavailable() {
PartTransferPendingReason::SourceUnavailable
} else if self.plan.all_dispatched(self.parts_dispatched, self.eof) {
PartTransferPendingReason::DispatchClosed
} else {
PartTransferPendingReason::NoReadyPart
}
}
fn record_dispatch_closed(&mut self) {
self.observability
.set_dispatch_closed(self.plan.all_dispatched(self.parts_dispatched, self.eof));
}
#[cfg(test)]
pub(crate) fn test_counts(&self) -> (u64, usize, usize) {
(
self.parts_dispatched,
self.parts_in_flight,
self.pending_reads.entries.len(),
)
}
#[cfg(test)]
pub(crate) fn test_summary(&self) -> MultipartTransferSummary {
self.observability
.test_summary(self.snapshot())
.expect("test transfer diagnostics should be enabled")
}
}
pub(crate) struct MultipartCompletion {
pub(crate) part_reader: Arc<PartReader>,
pub(crate) plan: PartPlan,
pub(crate) completed_parts: Vec<CompletedPart>,
pub(crate) bytes_read: u64,
pub(crate) final_snapshot: UploadStateSnapshot,
}
#[derive(Debug)]
pub(crate) enum UploadState {
PendingInit {
stream: Option<InputStream>,
size_hint: SizeHint,
init_in_flight: bool,
},
Transferring {
upload_id: String,
parts: PartTransferState,
response_builder: UploadOutputBuilder,
},
Completing {
upload_id: String,
parts: PartTransferState,
response_builder: UploadOutputBuilder,
},
CompleteInFlight { upload_id: String },
PutObjectInFlight,
Aborting {
upload_id: Option<String>,
create_in_flight: bool,
complete_mpu_in_flight: bool,
abort_mpu: AbortMpuProgress,
failure: Option<UploadFailure>,
},
Done,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum AbortMpuProgress {
NotNeeded,
ToSend,
InFlight,
Done,
Failed,
}
#[derive(Debug)]
pub(crate) struct UploadFailure {
pub(crate) error: crate::error::Error,
pub(crate) snapshot: UploadStateSnapshot,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn known_and_end_of_stream_plans_close_at_their_own_boundaries() {
let known = PartPlan::Known {
total_parts: 10_000,
declared_object_size: 100 * 1024 * 1024 * 1024,
};
assert!(!known.all_dispatched(1, true));
assert!(known.all_dispatched(10_000, false));
let until_eof = PartPlan::UntilEof {
size_hint: SizeHint::default().with_upper(Some(10)),
};
assert!(!until_eof.all_dispatched(10_000, false));
assert!(until_eof.all_dispatched(1, true));
}
#[test]
fn known_plan_can_complete_without_an_extra_end_of_stream_poll() {
let known = PartPlan::Known {
total_parts: 2,
declared_object_size: 10,
};
assert!(!known.all_dispatched(1, false));
assert!(known.all_dispatched(2, false));
}
#[test]
fn end_of_stream_bounds_reject_underflow_and_overflow() {
let bounded = PartPlan::UntilEof {
size_hint: SizeHint::default().with_lower(5).with_upper(Some(10)),
};
assert!(bounded.validate_complete(4).is_err());
assert!(bounded.validate_complete(5).is_ok());
assert!(bounded.validate_complete(10).is_ok());
assert!(bounded.validate_complete(11).is_err());
}
#[test]
fn exact_size_remains_the_mpu_object_size_witness() {
let exact = PartPlan::UntilEof {
size_hint: SizeHint::exact(7),
};
assert_eq!(7, exact.mpu_object_size(7).unwrap());
let bounded = PartPlan::UntilEof {
size_hint: SizeHint::default().with_lower(5).with_upper(Some(10)),
};
assert_eq!(7, bounded.mpu_object_size(7).unwrap());
}
#[test]
fn content_length_narrows_bounds_to_an_exact_size() {
let bounds = |hint: SizeHint| (hint.lower(), hint.upper());
let bounded = SizeHint::default().with_lower(5).with_upper(Some(10));
assert_eq!(
(5, Some(10)),
bounds(apply_content_length(bounded, None).unwrap())
);
for content_length in [5, 7, 10] {
let declared = content_length as u64;
assert_eq!(
(declared, Some(declared)),
bounds(apply_content_length(bounded, Some(content_length)).unwrap())
);
}
for content_length in [4, 11] {
assert!(matches!(
apply_content_length(bounded, Some(content_length)),
Err(ContentLengthViolation::OutsideBounds { .. })
));
}
assert!(matches!(
apply_content_length(SizeHint::default(), Some(-1)),
Err(ContentLengthViolation::Negative { content_length: -1 })
));
let largest = i64::MAX as u64;
assert_eq!(
(largest, Some(largest)),
bounds(apply_content_length(SizeHint::default(), Some(i64::MAX)).unwrap())
);
}
#[test]
fn part_numbers_within_s3_range_are_accepted_in_any_order() {
for part_number in [MAX_PART_NUMBER, 65, 64, 1, 2] {
validate_part_number(part_number).unwrap();
}
for part_number in [0, MAX_PART_NUMBER + 1, (1 << 32) + 1, u64::MAX] {
assert!(matches!(
validate_part_number(part_number),
Err(PartNumberViolation::OutsideRange { part_number: n }) if n == part_number
));
}
}
#[test]
fn repeated_part_numbers_are_found_in_the_assembled_part_list() {
let part = |n: i32| CompletedPart::builder().part_number(n).build();
validate_distinct_part_numbers(&[]).unwrap();
validate_distinct_part_numbers(&[part(1)]).unwrap();
validate_distinct_part_numbers(&[part(1), part(2), part(7)]).unwrap();
assert!(matches!(
validate_distinct_part_numbers(&[part(1), part(2), part(2), part(3)]),
Err(PartNumberViolation::Repeated { part_number: 2 })
));
}
#[test]
fn wake_before_parking_remains_notified() {
let wake = PartReadWake::new(Waker::noop().clone());
Arc::clone(&wake).wake();
assert!(wake.take_notification());
assert!(!wake.take_notification());
}
}