AWS SDK

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/event_stream/receiver.rs

@@ -142,142 +213,216 @@

-142
 impl<T, E> Receiver<T, E> {
     /// Creates a new `Receiver` with the given message unmarshaller and SDK body.
     pub fn new(
         unmarshaller: impl UnmarshallMessage<Output = T, Error = E> + Send + Sync + 'static,
         body: SdkBody,
     ) -> Self {
         Receiver {
             unmarshaller: Box::new(unmarshaller),
             decoder: MessageFrameDecoder::new(),
             buffer: RecvBuf::Empty,
             body,
             buffered_message: None,
             _phantom: Default::default(),
-156
+        }
-157
+    }
-158
     fn unmarshall(&self, message: Message) -> Result<Option<T>, SdkError<E, RawMessage>> {
         match self.unmarshaller.unmarshall(&message) {
             Ok(unmarshalled) => match unmarshalled {

                 UnmarshalledMessage::Event(event) => Ok(Some(event)),
                 UnmarshalledMessage::Error(err) => {
                     Err(SdkError::service_error(err, RawMessage::Decoded(message)))
-165
+                }
             },
             Err(err) => Err(SdkError::response_error(err, RawMessage::Decoded(message))),
-168
+        }
-169
+    }
-170
     async fn buffer_next_chunk(&mut self) -> Result<(), SdkError<E, RawMessage>> {
         use http_body_04x::Body;
         use http_body_util::BodyExt;
-173
         if !self.buffer.is_eos() {
             let next_chunk = self
                 .body
                 .data()
                 .frame()
                 .await
                 .transpose()
                 .map_err(|err| SdkError::dispatch_failure(ConnectorError::io(err)))?;
             let buffer = mem::replace(&mut self.buffer, RecvBuf::Empty);
             if let Some(chunk) = next_chunk {
                 self.buffer = buffer.with_partial(chunk);
                 // Ignoring the possibility of trailers here since event_streams don't have them
                 if let Ok(data) = chunk.into_data() {
                     self.buffer = buffer.with_partial(data);
-+
+                }
             } else {
                 self.buffer = buffer.ended();
-189
+            }
-190
+        }
         Ok(())
-192
+    }
-193
     async fn next_message(&mut self) -> Result<Option<Message>, SdkError<E, RawMessage>> {
         while !self.buffer.is_eos() {
             if self.buffer.has_data() {

↧ Expand context

                 if let DecodedFrame::Complete(message) = self
                     .decoder
                     .decode_frame(self.buffer.buffered())
                     .map_err(|err| {
                         SdkError::response_error(
                             err,
                             // the buffer has been consumed
                             RawMessage::Invalid(None),
-205
+                        )
                     })?
-207
+                {
                     trace!(message = ?message, "received complete event stream message");
                     return Ok(Some(message));
-210
+                }
-211
+            }
-212
             self.buffer_next_chunk().await?;
-214
+        }
         if self.buffer.has_data() {
             trace!(remaining_data = ?self.buffer, "data left over in the event stream response stream");

@@ -283,286 +592,616 @@

↥ Expand context

                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
-290
+                }
             };
-292
+        }
         if let Some(message) = self.next_message().await? {
             match self.unmarshall(message) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
-299
+                }
-300
+            }
         } else {
             Ok(None)
-303
+        }
-304
+    }
-305
+}

-306
 #[cfg(test)]
 mod tests {
     use super::{InitialMessageType, Receiver, UnmarshallMessage};
     use aws_smithy_eventstream::error::Error as EventStreamError;
     use aws_smithy_eventstream::frame::{write_message_to, UnmarshalledMessage};
     use aws_smithy_runtime_api::client::result::SdkError;
     use aws_smithy_types::body::SdkBody;
     use aws_smithy_types::event_stream::{Header, HeaderValue, Message};
     use bytes::Bytes;
     use hyper::body::Body;
     use http_body_1x::Frame;
     use std::error::Error as StdError;
     use std::io::{Error as IOError, ErrorKind};
-319
     fn encode_initial_response() -> Bytes {
         let mut buffer = Vec::new();
         let message = Message::new(Bytes::new())
             .add_header(Header::new(
                 ":message-type",
                 HeaderValue::String("event".into()),
             ))
             .add_header(Header::new(
                 ":event-type",
                 HeaderValue::String("initial-response".into()),
             ));
         write_message_to(&message, &mut buffer).unwrap();
         buffer.into()
-333
+    }
-334
     fn encode_message(message: &str) -> Bytes {
         let mut buffer = Vec::new();
         let message = Message::new(Bytes::copy_from_slice(message.as_bytes()));
         write_message_to(&message, &mut buffer).unwrap();
         buffer.into()
-340
+    }
-341
     fn map_to_frame(stream: Vec<Result<Bytes, IOError>>) -> Vec<Result<Frame<Bytes>, IOError>> {
         stream
             .into_iter()
             .map(|chunk| chunk.map(Frame::data))
             .collect()
-+
+    }
-+
     #[derive(Debug)]
     struct FakeError;
     impl std::fmt::Display for FakeError {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(f, "FakeError")
-354
+        }
-355
+    }
     impl StdError for FakeError {}
-357
     #[derive(Debug, Eq, PartialEq)]
     struct TestMessage(String);
-360
     #[derive(Debug)]
     struct Unmarshaller;
     impl UnmarshallMessage for Unmarshaller {
         type Output = TestMessage;
         type Error = EventStreamError;
-366
         fn unmarshall(
             &self,
             message: &Message,
         ) -> Result<UnmarshalledMessage<Self::Output, Self::Error>, EventStreamError> {
             Ok(UnmarshalledMessage::Event(TestMessage(
                 std::str::from_utf8(&message.payload()[..]).unwrap().into(),
             )))
-374
+        }
-375
+    }
-376
     #[tokio::test]
     async fn receive_success() {
         let chunks: Vec<Result<_, IOError>> =
             vec![Ok(encode_message("one")), Ok(encode_message("two"))];
             map_to_frame(vec![Ok(encode_message("one")), Ok(encode_message("two"))]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
-+
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
-+
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("two".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(None, receiver.recv().await.unwrap());
-396
+    }
-397
     #[tokio::test]
     async fn receive_last_chunk_empty() {
         let chunks: Vec<Result<_, IOError>> = vec![
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_message("one")),
             Ok(encode_message("two")),
             Ok(Bytes::from_static(&[])),
         ];
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("two".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(None, receiver.recv().await.unwrap());
-418
+    }
-419
     #[tokio::test]
     async fn receive_last_chunk_not_full_message() {
         let chunks: Vec<Result<_, IOError>> = vec![
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_message("one")),
             Ok(encode_message("two")),
             Ok(encode_message("three").split_to(10)),
         ];
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("two".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert!(matches!(
             receiver.recv().await,
             Err(SdkError::ResponseError { .. }),
         ));
-443
+    }
-444
     #[tokio::test]
     async fn receive_last_chunk_has_multiple_messages() {
         let chunks: Vec<Result<_, IOError>> = vec![
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_message("one")),
             Ok(encode_message("two")),
             Ok(Bytes::from(
                 [encode_message("three"), encode_message("four")].concat(),
             )),
         ];
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("two".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("three".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("four".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(None, receiver.recv().await.unwrap());
-475
+    }
-476
     proptest::proptest! {
         #[test]
         fn receive_multiple_messages_split_unevenly_across_chunks(b1: usize, b2: usize) {
             let combined = Bytes::from([
                 encode_message("one"),
                 encode_message("two"),
                 encode_message("three"),
                 encode_message("four"),
                 encode_message("five"),
                 encode_message("six"),
                 encode_message("seven"),
                 encode_message("eight"),
             ].concat());
-490
             let midpoint = combined.len() / 2;
             let (start, boundary1, boundary2, end) = (
 ,
                 b1 % midpoint,
                 midpoint + b2 % midpoint,
                 combined.len()
             );
             println!("[{start}, {boundary1}], [{boundary1}, {boundary2}], [{boundary2}, {end}]");
-499
             let rt = tokio::runtime::Runtime::new().unwrap();
             rt.block_on(async move {
                 let chunks: Vec<Result<_, IOError>> = vec![
                 let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
                     Ok(Bytes::copy_from_slice(&combined[start..boundary1])),
                     Ok(Bytes::copy_from_slice(&combined[boundary1..boundary2])),
                     Ok(Bytes::copy_from_slice(&combined[boundary2..end])),
                 ];
                 ]);
-507
                 let chunk_stream = futures_util::stream::iter(chunks);
                 let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
                 let stream_body = http_body_util::StreamBody::new(chunk_stream);
                 let body = SdkBody::from_body_1_x(stream_body);
                 let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
                 for payload in &["one", "two", "three", "four", "five", "six", "seven", "eight"] {
                     assert_eq!(
                         TestMessage((*payload).into()),
                         receiver.recv().await.unwrap().unwrap()
                     );
-517
+                }
                 assert_eq!(None, receiver.recv().await.unwrap());
             });
-520
+        }
-521
+    }
-522
     #[tokio::test]
     async fn receive_network_failure() {
         let chunks: Vec<Result<_, IOError>> = vec![
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_message("one")),
             Err(IOError::new(ErrorKind::ConnectionReset, FakeError)),
         ];
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert!(matches!(
             receiver.recv().await,
             Err(SdkError::DispatchFailure(_))
         ));
-541
+    }
-542
     #[tokio::test]
     async fn receive_message_parse_failure() {
         let chunks: Vec<Result<_, IOError>> = vec![
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_message("one")),
             // A zero length message will be invalid. We need to provide a minimum of 12 bytes
             // for the MessageFrameDecoder to actually start parsing it.
             Ok(Bytes::from_static(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])),
         ];
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert!(matches!(
             receiver.recv().await,
             Err(SdkError::ResponseError { .. })
         ));
-563
+    }
-564
     #[tokio::test]
     async fn receive_initial_response() {
         let chunks: Vec<Result<_, IOError>> =
             vec![Ok(encode_initial_response()), Ok(encode_message("one"))];
         let chunks: Vec<Result<_, IOError>> = map_to_frame(vec![
             Ok(encode_initial_response()),
             Ok(encode_message("one")),
         ]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert!(receiver
             .try_recv_initial(InitialMessageType::Response)
             .await
             .unwrap()
             .is_some());
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );
-584
+    }
-585
     #[tokio::test]
     async fn receive_no_initial_response() {
         let chunks: Vec<Result<_, IOError>> =
             vec![Ok(encode_message("one")), Ok(encode_message("two"))];
             map_to_frame(vec![Ok(encode_message("one")), Ok(encode_message("two"))]);
         let chunk_stream = futures_util::stream::iter(chunks);
         let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
         let stream_body = http_body_util::StreamBody::new(chunk_stream);
-+
         let body = SdkBody::from_body_1_x(stream_body);
         let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
         assert!(receiver
             .try_recv_initial(InitialMessageType::Response)
             .await
             .unwrap()
             .is_none());
         assert_eq!(
             TestMessage("one".into()),
             receiver.recv().await.unwrap().unwrap()
         );

↧ Expand context

         assert_eq!(
             TestMessage("two".into()),
             receiver.recv().await.unwrap().unwrap()
         );
-608
+    }
-609
     fn assert_send_and_sync<T: Send + Sync>() {}
-611
     #[tokio::test]
     async fn receiver_is_send_and_sync() {
         assert_send_and_sync::<Receiver<(), ()>>();
-615
+    }
-616
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/header.rs

@@ -1,1 +41,41 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Utilities for parsing information from headers
-7
 use aws_smithy_types::date_time::Format;
 use aws_smithy_types::primitive::Parse;
 use aws_smithy_types::DateTime;
 use http_02x::header::{HeaderMap, HeaderName, HeaderValue};
 use http_1x::header::{HeaderMap, HeaderName, HeaderValue};
 use std::borrow::Cow;
 use std::error::Error;
 use std::fmt;
 use std::str::FromStr;
-16
 /// An error was encountered while parsing a header
 #[derive(Debug)]
 pub struct ParseError {
     message: Cow<'static, str>,
     source: Option<Box<dyn Error + Send + Sync + 'static>>,

↧ Expand context

-22
+}
-23
 impl ParseError {
     /// Create a new parse error with the given `message`
     pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
         Self {
             message: message.into(),
             source: None,
-30
+        }
-31
+    }
-32
     /// Attach a source to this error.
     pub fn with_source(self, source: impl Into<Box<dyn Error + Send + Sync + 'static>>) -> Self {
         Self {
             source: Some(source.into()),
             ..self
-38
+        }
-39
+    }
-40
+}
-41

@@ -124,124 +211,211 @@

↥ Expand context

-124
+        }
-125
+    }
     Ok(out)
-127
+}
-128
 /// Read exactly one or none from a headers iterator
 ///
 /// This function does not perform comma splitting like `read_many`
 pub fn one_or_none<'a, T: FromStr>(
     mut values: impl Iterator<Item = &'a str>,
 ) -> Result<Option<T>, ParseError>
 where
     T::Err: Error + Send + Sync + 'static,
-137
+{
     let first = match values.next() {
         Some(v) => v,
         None => return Ok(None),
     };
     match values.next() {
         None => T::from_str(first.trim())

             .map_err(|err| ParseError::new("failed to parse string").with_source(err))
             .map(Some),
         Some(_) => Err(ParseError::new(
             "expected a single value but found multiple",
         )),
-149
+    }
-150
+}
-151
 /// Given an HTTP request, set a request header if that header was not already set.
 pub fn set_request_header_if_absent<V>(
     request: http_02x::request::Builder,
     request: http_1x::request::Builder,
     key: HeaderName,
     value: V,
 ) -> http_02x::request::Builder
 ) -> http_1x::request::Builder
 where
     HeaderValue: TryFrom<V>,
     <HeaderValue as TryFrom<V>>::Error: Into<http_02x::Error>,
     <HeaderValue as TryFrom<V>>::Error: Into<http_1x::Error>,
-161
+{
     if !request
         .headers_ref()
         .map(|map| map.contains_key(&key))
         .unwrap_or(false)
-166
+    {
         request.header(key, value)
     } else {
         request
-170
+    }
-171
+}
-172
 /// Given an HTTP response, set a response header if that header was not already set.
 pub fn set_response_header_if_absent<V>(
     response: http_02x::response::Builder,
     response: http_1x::response::Builder,
     key: HeaderName,
     value: V,
 ) -> http_02x::response::Builder
 ) -> http_1x::response::Builder
 where
     HeaderValue: TryFrom<V>,
     <HeaderValue as TryFrom<V>>::Error: Into<http_02x::Error>,
     <HeaderValue as TryFrom<V>>::Error: Into<http_1x::Error>,
-182
+{
     if !response
         .headers_ref()
         .map(|map| map.contains_key(&key))
         .unwrap_or(false)
-187
+    {
         response.header(key, value)
     } else {
         response
-191
+    }

↧ Expand context

-192
+}
-193
 /// Functions for parsing multiple comma-delimited header values out of a
 /// single header. This parsing adheres to
 /// [RFC-7230's specification of header values](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6).
 mod parse_multi_header {
     use super::ParseError;
     use std::borrow::Cow;
-200
     fn trim(s: Cow<'_, str>) -> Cow<'_, str> {
         match s {
             Cow::Owned(s) => Cow::Owned(s.trim().into()),
             Cow::Borrowed(s) => Cow::Borrowed(s.trim()),
-205
+        }
-206
+    }
-207
     fn replace<'a>(value: Cow<'a, str>, pattern: &str, replacement: &str) -> Cow<'a, str> {
         if value.contains(pattern) {
             Cow::Owned(value.replace(pattern, replacement))
         } else {

@@ -275,275 +557,584 @@

↥ Expand context

-275
+    }
-276
+}
-277
 /// Read one comma delimited value for `FromStr` types
 fn read_one<'a, T>(
     s: &'a [u8],
     f: &impl Fn(&str) -> Result<T, ParseError>,
 ) -> Result<(T, &'a [u8]), ParseError> {
     let (value, rest) = parse_multi_header::read_value(s)?;
     Ok((f(&value)?, rest))
-285
+}
-286
 /// Conditionally quotes and escapes a header value if the header value contains a comma or quote.
 pub fn quote_header_value<'a>(value: impl Into<Cow<'a, str>>) -> Cow<'a, str> {
     let value = value.into();
     if value.trim().len() != value.len()
         || value.contains('"')
         || value.contains(',')
         || value.contains('(')
         || value.contains(')')

-295
+    {
         Cow::Owned(format!(
             "\"{}\"",
             value.replace('\\', "\\\\").replace('"', "\\\"")
         ))
     } else {
         value
-302
+    }
-303
+}
-304
 /// Given two [`HeaderMap`]s, merge them together and return the merged `HeaderMap`. If the
 /// Given two http-02x [`HeaderMap`]s, merge them together and return the merged `HeaderMap`. If the
 /// two `HeaderMap`s share any keys, values from the right `HeaderMap` be appended to the left `HeaderMap`.
 pub fn append_merge_header_maps(
     mut lhs: HeaderMap<HeaderValue>,
     rhs: HeaderMap<HeaderValue>,
 ) -> HeaderMap<HeaderValue> {
     let mut last_header_name_seen = None;
     for (header_name, header_value) in rhs.into_iter() {
         // For each yielded item that has None provided for the `HeaderName`,
         // then the associated header name is the same as that of the previously
         // yielded item. The first yielded item will have `HeaderName` set.
         // https://docs.rs/http/latest/http/header/struct.HeaderMap.html#method.into_iter-2
         match (&mut last_header_name_seen, header_name) {
             (_, Some(header_name)) => {
                 lhs.append(header_name.clone(), header_value);
                 last_header_name_seen = Some(header_name);
-321
+            }
             (Some(header_name), None) => {
                 lhs.append(header_name.clone(), header_value);
-324
+            }
             (None, None) => unreachable!(),
         };
-327
+    }
-328
     lhs
-330
+}
-331
 /// Given two http-1x [`HeaderMap`]s, merge them together and return the merged `HeaderMap`. If the
 /// two `HeaderMap`s share any keys, values from the right `HeaderMap` be appended to the left `HeaderMap`.
 pub fn append_merge_header_maps_http_1x(
     mut lhs: http_1x::HeaderMap<http_1x::HeaderValue>,
     rhs: http_1x::HeaderMap<http_1x::HeaderValue>,
 ) -> http_1x::HeaderMap<http_1x::HeaderValue> {
     let mut last_header_name_seen = None;
     for (header_name, header_value) in rhs.into_iter() {
         // For each yielded item that has None provided for the `HeaderName`,
         // then the associated header name is the same as that of the previously
         // yielded item. The first yielded item will have `HeaderName` set.
         // https://docs.rs/http/latest/http/header/struct.HeaderMap.html#method.into_iter-2
         match (&mut last_header_name_seen, header_name) {
             (_, Some(header_name)) => {
                 lhs.append(header_name.clone(), header_value);
                 last_header_name_seen = Some(header_name);
-+
+            }
             (Some(header_name), None) => {
                 lhs.append(header_name.clone(), header_value);
-+
+            }
             (None, None) => unreachable!(),
         };
-+
+    }
-+
     lhs
-+
+}
-+
 #[cfg(test)]
 mod test {
     use super::quote_header_value;
     use crate::header::{
         append_merge_header_maps, headers_for_prefix, many_dates, read_many_from_str,
         read_many_primitive, set_request_header_if_absent, set_response_header_if_absent,
         ParseError,
     };
     use aws_smithy_runtime_api::http::Request;
     use aws_smithy_types::error::display::DisplayErrorContext;
     use aws_smithy_types::{date_time::Format, DateTime};
     use http_02x::header::{HeaderMap, HeaderName, HeaderValue};
     use http_1x::header::{HeaderMap, HeaderName, HeaderValue};
     use std::collections::HashMap;
-372
     #[test]
     fn put_on_request_if_absent() {
         let builder = http_02x::Request::builder().header("foo", "bar");
         let builder = http_1x::Request::builder().header("foo", "bar");
         let builder = set_request_header_if_absent(builder, HeaderName::from_static("foo"), "baz");
         let builder =
             set_request_header_if_absent(builder, HeaderName::from_static("other"), "value");
         let req = builder.body(()).expect("valid request");
         assert_eq!(
             req.headers().get_all("foo").iter().collect::<Vec<_>>(),
             vec!["bar"]
         );
         assert_eq!(
             req.headers().get_all("other").iter().collect::<Vec<_>>(),
             vec!["value"]
         );
-388
+    }
-389
     #[test]
     fn put_on_response_if_absent() {
         let builder = http_02x::Response::builder().header("foo", "bar");
         let builder = http_1x::Response::builder().header("foo", "bar");
         let builder = set_response_header_if_absent(builder, HeaderName::from_static("foo"), "baz");
         let builder =
             set_response_header_if_absent(builder, HeaderName::from_static("other"), "value");
         let response = builder.body(()).expect("valid response");
         assert_eq!(
             response.headers().get_all("foo").iter().collect::<Vec<_>>(),
             vec!["bar"]
         );
         assert_eq!(
             response
                 .headers()
                 .get_all("other")
                 .iter()
                 .collect::<Vec<_>>(),
             vec!["value"]
         );
-409
+    }
-410
     #[test]
     fn parse_floats() {
         let test_request = http_02x::Request::builder()
         let test_request = http_1x::Request::builder()
             .header("X-Float-Multi", "0.0,Infinity,-Infinity,5555.5")
             .header("X-Float-Error", "notafloat")
             .body(())
             .unwrap();
         assert_eq!(
             read_many_primitive::<f32>(
                 test_request
                     .headers()
                     .get_all("X-Float-Multi")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-425
+            )
             .expect("valid"),
             vec![0.0, f32::INFINITY, f32::NEG_INFINITY, 5555.5]
         );
         let message = format!(
             "{}",
             DisplayErrorContext(
                 read_many_primitive::<f32>(
                     test_request
                         .headers()
                         .get_all("X-Float-Error")
                         .iter()
                         .map(|v| v.to_str().unwrap())
-438
+                )
                 .expect_err("invalid")
-440
+            )
         );
         let expected = "output failed to parse in headers: failed reading a list of primitives: failed to parse input as f32";
         assert!(
             message.starts_with(expected),
             "expected '{message}' to start with '{expected}'"
         );
-447
+    }
-448
     #[test]
     fn test_many_dates() {
         let test_request = http_02x::Request::builder()
         let test_request = http_1x::Request::builder()
             .header("Empty", "")
             .header("SingleHttpDate", "Wed, 21 Oct 2015 07:28:00 GMT")
             .header(
                 "MultipleHttpDates",
                 "Wed, 21 Oct 2015 07:28:00 GMT,Thu, 22 Oct 2015 07:28:00 GMT",
-457
+            )
             .header("SingleEpochSeconds", "1234.5678")
             .header("MultipleEpochSeconds", "1234.5678,9012.3456")
             .body(())
             .unwrap();
         let read = |name: &str, format: Format| {
             many_dates(
                 test_request
                     .headers()
                     .get_all(name)
                     .iter()
                     .map(|v| v.to_str().unwrap()),
                 format,
-470
+            )
         };
         let read_valid = |name: &str, format: Format| read(name, format).expect("valid");
         assert_eq!(
             read_valid("Empty", Format::DateTime),
             Vec::<DateTime>::new()
         );
         assert_eq!(
             read_valid("SingleHttpDate", Format::HttpDate),
             vec![DateTime::from_secs_and_nanos(1445412480, 0)]
         );
         assert_eq!(
             read_valid("MultipleHttpDates", Format::HttpDate),
             vec![
                 DateTime::from_secs_and_nanos(1445412480, 0),
                 DateTime::from_secs_and_nanos(1445498880, 0)
-486
+            ]
         );
         assert_eq!(
             read_valid("SingleEpochSeconds", Format::EpochSeconds),
             vec![DateTime::from_secs_and_nanos(1234, 567_800_000)]
         );
         assert_eq!(
             read_valid("MultipleEpochSeconds", Format::EpochSeconds),
             vec![
                 DateTime::from_secs_and_nanos(1234, 567_800_000),
                 DateTime::from_secs_and_nanos(9012, 345_600_000)
-497
+            ]
         );
-499
+    }
-500
     #[test]
     fn read_many_strings() {
         let test_request = http_02x::Request::builder()
         let test_request = http_1x::Request::builder()
             .header("Empty", "")
             .header("Foo", "  foo")
             .header("FooTrailing", "foo   ")
             .header("FooInQuotes", "\"  foo  \"")
             .header("CommaInQuotes", "\"foo,bar\",baz")
             .header("CommaInQuotesTrailing", "\"foo,bar\",baz  ")
             .header("QuoteInQuotes", "\"foo\\\",bar\",\"\\\"asdf\\\"\",baz")
             .header(
                 "QuoteInQuotesWithSpaces",
                 "\"foo\\\",bar\", \"\\\"asdf\\\"\", baz",
-514
+            )
             .header("JunkFollowingQuotes", "\"\\\"asdf\\\"\"baz")
             .header("EmptyQuotes", "\"\",baz")
             .header("EscapedSlashesInQuotes", "foo, \"(foo\\\\bar)\"")
             .body(())
             .unwrap();
         let read = |name: &str| {
             read_many_from_str::<String>(
                 test_request
                     .headers()
                     .get_all(name)
                     .iter()
                     .map(|v| v.to_str().unwrap()),
-527
+            )
         };
         let read_valid = |name: &str| read(name).expect("valid");
         assert_eq!(read_valid("Empty"), Vec::<String>::new());
         assert_eq!(read_valid("Foo"), vec!["foo"]);
         assert_eq!(read_valid("FooTrailing"), vec!["foo"]);
         assert_eq!(read_valid("FooInQuotes"), vec!["  foo  "]);
         assert_eq!(read_valid("CommaInQuotes"), vec!["foo,bar", "baz"]);
         assert_eq!(read_valid("CommaInQuotesTrailing"), vec!["foo,bar", "baz"]);
         assert_eq!(
             read_valid("QuoteInQuotes"),
             vec!["foo\",bar", "\"asdf\"", "baz"]
         );
         assert_eq!(
             read_valid("QuoteInQuotesWithSpaces"),
             vec!["foo\",bar", "\"asdf\"", "baz"]
         );
         assert!(read("JunkFollowingQuotes").is_err());
         assert_eq!(read_valid("EmptyQuotes"), vec!["", "baz"]);
         assert_eq!(
             read_valid("EscapedSlashesInQuotes"),
             vec!["foo", "(foo\\bar)"]
         );
-550
+    }
-551
     #[test]
     fn read_many_bools() {
         let test_request = http_02x::Request::builder()
         let test_request = http_1x::Request::builder()
             .header("X-Bool-Multi", "true,false")
             .header("X-Bool-Multi", "true")
             .header("X-Bool", "true")
             .header("X-Bool-Invalid", "truth,falsy")
             .header("X-Bool-Single", "true,false,true,true")
             .header("X-Bool-Quoted", "true,\"false\",true,true")
             .body(())
             .unwrap();
         assert_eq!(
             read_many_primitive::<bool>(

↧ Expand context

                 test_request
                     .headers()
                     .get_all("X-Bool-Multi")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-570
+            )
             .expect("valid"),
             vec![true, false, true]
         );
-574
         assert_eq!(
             read_many_primitive::<bool>(
                 test_request
                     .headers()
                     .get_all("X-Bool")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-582
+            )
             .unwrap(),
             vec![true]

@@ -563,590 +623,650 @@

↥ Expand context

                     .get_all("X-Bool-Single")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-593
+            )
             .unwrap(),
             vec![true, false, true, true]
         );
         assert_eq!(
             read_many_primitive::<bool>(
                 test_request
                     .headers()
                     .get_all("X-Bool-Quoted")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-604
+            )
             .unwrap(),
             vec![true, false, true, true]
         );
         read_many_primitive::<bool>(
             test_request

                 .headers()
                 .get_all("X-Bool-Invalid")
                 .iter()
                 .map(|v| v.to_str().unwrap()),
-614
+        )
         .expect_err("invalid");
-616
+    }
-617
     #[test]
     fn check_read_many_i16() {
         let test_request = http_02x::Request::builder()
         let test_request = http_1x::Request::builder()
             .header("X-Multi", "123,456")
             .header("X-Multi", "789")
             .header("X-Num", "777")
             .header("X-Num-Invalid", "12ef3")
             .header("X-Num-Single", "1,2,3,-4,5")
             .header("X-Num-Quoted", "1, \"2\",3,\"-4\",5")
             .body(())
             .unwrap();
         assert_eq!(
             read_many_primitive::<i16>(

↧ Expand context

                 test_request
                     .headers()
                     .get_all("X-Multi")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-636
+            )
             .expect("valid"),
             vec![123, 456, 789]
         );
-640
         assert_eq!(
             read_many_primitive::<i16>(
                 test_request
                     .headers()
                     .get_all("X-Num")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-648
+            )
             .unwrap(),
             vec![777]

@@ -630,657 +690,717 @@

↥ Expand context

                     .iter()
                     .map(|v| v.to_str().unwrap())
-659
+            )
             .unwrap(),
             vec![1, 2, 3, -4, 5]
         );
         assert_eq!(
             read_many_primitive::<i16>(
                 test_request
                     .headers()
                     .get_all("X-Num-Quoted")
                     .iter()
                     .map(|v| v.to_str().unwrap())
-670
+            )
             .unwrap(),
             vec![1, 2, 3, -4, 5]
         );
         read_many_primitive::<i16>(
             test_request
                 .headers()

                 .get_all("X-Num-Invalid")
                 .iter()
                 .map(|v| v.to_str().unwrap()),
-680
+        )
         .expect_err("invalid");
-682
+    }
-683
     #[test]
     fn test_prefix_headers() {
         let test_request = Request::try_from(
             http_02x::Request::builder()
             http_1x::Request::builder()
                 .header("X-Prefix-A", "123,456")
                 .header("X-Prefix-B", "789")
                 .header("X-Prefix-C", "777")
                 .header("X-Prefix-C", "777")
                 .body(())
                 .unwrap(),
-694
+        )
         .unwrap();
         let resp: Result<HashMap<String, Vec<i16>>, ParseError> =
             headers_for_prefix(test_request.headers().iter().map(|h| h.0), "X-Prefix-")

↧ Expand context

                 .map(|(key, header_name)| {
                     let values = test_request.headers().get_all(header_name);
                     read_many_primitive(values).map(|v| (key.to_string(), v))
                 })
                 .collect();
         let resp = resp.expect("valid");
         assert_eq!(resp.get("a"), Some(&vec![123_i16, 456_i16]));
-705
+    }
-706
     #[test]
     fn test_quote_header_value() {
         assert_eq!("", &quote_header_value(""));
         assert_eq!("foo", &quote_header_value("foo"));
         assert_eq!("\"  foo\"", &quote_header_value("  foo"));
         assert_eq!("foo bar", &quote_header_value("foo bar"));
         assert_eq!("\"foo,bar\"", &quote_header_value("foo,bar"));
         assert_eq!("\",\"", &quote_header_value(","));
         assert_eq!("\"\\\"foo\\\"\"", &quote_header_value("\"foo\""));
         assert_eq!("\"\\\"f\\\\oo\\\"\"", &quote_header_value("\"f\\oo\""));
         assert_eq!("\"(\"", &quote_header_value("("));

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/label.rs

@@ -14,14 +64,64 @@

↥ Expand context

 const GREEDY: &AsciiSet = &BASE_SET.remove(b'/');
-15
 /// The encoding strategy used when parsing an `httpLabel`.
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum EncodingStrategy {
     /// The default strategy when parsing an `httpLabel`. Only one path segment will be matched.
     Default,
     /// When parsing an `httpLabel`, this strategy will attempt to parse as many path segments as possible.
     Greedy,
-24
+}
-25
 /// Format a given `httpLabel` as a string according to an [`EncodingStrategy`]
 pub fn fmt_string<T: AsRef<str>>(t: T, strategy: EncodingStrategy) -> String {
     let uri_set = if strategy == EncodingStrategy::Greedy {
         GREEDY
     } else {
         BASE_SET
     };
     percent_encoding::utf8_percent_encode(t.as_ref(), uri_set).to_string()

-34
+}
-35
 /// Format a given [`DateTime`] as a string according to an [`EncodingStrategy`]
 pub fn fmt_timestamp(t: &DateTime, format: Format) -> Result<String, DateTimeFormatError> {
     Ok(fmt_string(t.fmt(format)?, EncodingStrategy::Default))
-39
+}
-40
 #[cfg(test)]
 mod test {
     use crate::label::{fmt_string, EncodingStrategy};
     use http_02x::Uri;
     use http_1x::Uri;
     use proptest::proptest;
-46
     #[test]
     fn greedy_params() {
         assert_eq!(fmt_string("a/b", EncodingStrategy::Default), "a%2Fb");
         assert_eq!(fmt_string("a/b", EncodingStrategy::Greedy), "a/b");
-51
+    }
-52
     proptest! {
         #[test]

↧ Expand context

         fn test_encode_request(s: String) {
             let _: Uri = format!("http://host.example.com/{}", fmt_string(&s, EncodingStrategy::Default))
                 .parse()
                 .expect("all strings should be encoded properly");
             let _: Uri = format!("http://host.example.com/{}", fmt_string(&s, EncodingStrategy::Greedy))
                 .parse()
                 .expect("all strings should be encoded properly");
-62
+        }
-63
+    }
-64
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/query.rs

@@ -38,38 +97,97 @@

↥ Expand context

     out: &'a mut String,
     prefix: char,
-40
+}
-41
 impl<'a> Writer<'a> {
     /// Create a new query string writer.
     pub fn new(out: &'a mut String) -> Self {
         Writer { out, prefix: '?' }
-46
+    }
-47
     /// Add a new key and value pair to this writer.
     pub fn push_kv(&mut self, k: &str, v: &str) {
         self.out.push(self.prefix);
         self.out.push_str(k);
         self.out.push('=');
         self.out.push_str(v);
         self.prefix = '&';
-55
+    }
-56
     /// Add a new value (which is its own key) to this writer.

     pub fn push_v(&mut self, v: &str) {
         self.out.push(self.prefix);
         self.out.push_str(v);
         self.prefix = '&';
-62
+    }
-63
+}
-64
 #[cfg(test)]
 mod test {
     use crate::query::{fmt_string, Writer};
     use http_02x::Uri;
     use http_1x::Uri;
     use proptest::proptest;
-70
     #[test]
     fn url_encode() {
         assert_eq!(fmt_string("y̆").as_str(), "y%CC%86");
         assert_eq!(fmt_string(" ").as_str(), "%20");
         assert_eq!(fmt_string("foo/baz%20").as_str(), "foo%2Fbaz%2520");
         assert_eq!(fmt_string("&=").as_str(), "%26%3D");
         assert_eq!(fmt_string("🐱").as_str(), "%F0%9F%90%B1");
         // `:` needs to be encoded, but only for AWS services

↧ Expand context

         assert_eq!(fmt_string("a:b"), "a%3Ab")
-80
+    }
-81
     #[test]
     fn writer_sets_prefix_properly() {
         let mut out = String::new();
         let mut writer = Writer::new(&mut out);
         writer.push_v("a");
         writer.push_kv("b", "c");
         assert_eq!(out, "?a&b=c");
-89
+    }
-90
     proptest! {
         #[test]
         fn test_encode_request(s: String) {
             let _: Uri = format!("http://host.example.com/?{}", fmt_string(s)).parse().expect("all strings should be encoded properly");
-95
+        }
-96
+    }
-97
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/query_writer.rs

@@ -1,1 +38,38 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use crate::query::fmt_string as percent_encode_query;
 use http_02x::uri::InvalidUri;
 use http_02x::Uri;
 use http_1x::uri::InvalidUri;
 use http_1x::Uri;
-9
 /// Utility for updating the query string in a [`Uri`].
 #[allow(missing_debug_implementations)]
 pub struct QueryWriter {
     base_uri: Uri,
     new_path_and_query: String,
     prefix: Option<char>,
-16
+}
-17
 impl QueryWriter {

↧ Expand context

     /// Creates a new `QueryWriter` from a string
     pub fn new_from_string(uri: &str) -> Result<Self, InvalidUri> {
         Ok(Self::new(&Uri::try_from(uri)?))
-22
+    }
-23
     /// Creates a new `QueryWriter` based off the given `uri`.
     pub fn new(uri: &Uri) -> Self {
         let new_path_and_query = uri
             .path_and_query()
             .map(|pq| pq.to_string())
             .unwrap_or_default();
         let prefix = if uri.query().is_none() {
             Some('?')
         } else if !uri.query().unwrap_or_default().is_empty() {
             Some('&')
         } else {
             None
         };
         QueryWriter {
             base_uri: uri.clone(),

@@ -60,60 +120,120 @@

↥ Expand context

     pub fn insert_encoded(&mut self, encoded_k: &str, encoded_v: &str) {
         if let Some(prefix) = self.prefix {
             self.new_path_and_query.push(prefix);
-63
+        }
         self.prefix = Some('&');
         self.new_path_and_query.push_str(encoded_k);
         self.new_path_and_query.push('=');
         self.new_path_and_query.push_str(encoded_v)
-68
+    }
-69
     /// Returns just the built query string.
     pub fn build_query(self) -> String {
         self.build_uri().query().unwrap_or_default().to_string()
-73
+    }
-74
     /// Returns a full [`Uri`] with the query string updated.
     pub fn build_uri(self) -> Uri {
         let mut parts = self.base_uri.into_parts();
         parts.path_and_query = Some(
             self.new_path_and_query

                 .parse()
                 .expect("adding query should not invalidate URI"),
         );
         Uri::from_parts(parts).expect("a valid URL in should always produce a valid URL out")
-84
+    }
-85
+}
-86
 #[cfg(test)]
 mod test {
     use super::QueryWriter;
     use http_02x::Uri;
     use http_1x::Uri;
-91
     #[test]
     fn empty_uri() {
         let uri = Uri::from_static("http://www.example.com");
         let mut query_writer = QueryWriter::new(&uri);
         query_writer.insert("key", "val%ue");
         query_writer.insert("another", "value");
         assert_eq!(
             query_writer.build_uri(),
             Uri::from_static("http://www.example.com?key=val%25ue&another=value")

↧ Expand context

         );
-102
+    }
-103
     #[test]
     fn uri_with_path() {
         let uri = Uri::from_static("http://www.example.com/path");
         let mut query_writer = QueryWriter::new(&uri);
         query_writer.insert("key", "val%ue");
         query_writer.insert("another", "value");
         assert_eq!(
             query_writer.build_uri(),
             Uri::from_static("http://www.example.com/path?key=val%25ue&another=value")
         );
-114
+    }
-115
     #[test]
     fn uri_with_path_and_query() {
         let uri = Uri::from_static("http://www.example.com/path?original=here");
         let mut query_writer = QueryWriter::new(&uri);
         query_writer.insert("key", "val%ue");

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/Cargo.toml

@@ -1,1 +22,22 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-json"
 version = "0.61.9"
 version = "0.62.0"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "John DiSanti <jdisanti@amazon.com>"]
 description = "Token streaming JSON parser for smithy-rs."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.6"
 version = "1.4.0"
-19
 [dev-dependencies]
 proptest = "1"
 serde_json = "1.0"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/fuzz/Cargo.toml

@@ -1,1 +40,40 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [[bin]]
 name = "json_deserialize"
 path = "fuzz_targets/json_deserialize.rs"
 test = false
 doc = false
-7
 [[bin]]
 name = "json_deserialize_corpus_cov"
 path = "fuzz_targets/json_deserialize_corpus_cov.rs"
 test = false
 doc = false
-13
 [package]
 name = "aws-smithy-json-fuzz"
 version = "0.0.0"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "John DiSanti <jdisanti@amazon.com>"]
 publish = false

 edition = "2021"
-20
 [package.metadata]
 cargo-fuzz = true
-23
 [dependencies]
 libfuzzer-sys = "=0.4.7"
-26
 [dependencies.aws-smithy-json]
 path = ".."
 version = "0.61.9"
 version = "0.62.0"
-30
 [dependencies.aws-smithy-types]
 path = "../../aws-smithy-types"
 version = "1.3.6"
 version = "1.4.0"
-34
 [dependencies.serde_json]
 version = "1"
 features = ["float_roundtrip"]
-38
 [workspace]
 members = ["."]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/Cargo.toml

@@ -1,1 +75,75 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-legacy-http"
 version = "0.62.6"
 version = "0.62.7"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "Smithy HTTP-0x logic for smithy-rs."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [features]
 event-stream = ["aws-smithy-eventstream"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
-20
 [dependencies]
 bytes = "1.10.0"
 bytes-utils = "0.1"
 percent-encoding = "2.3.1"
 pin-project-lite = "0.2.14"
 pin-utils = "0.1.0"
 tracing = "0.1.40"
 futures-core = "0.3.31"
-29
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 optional = true
 version = "0.60.14"
 version = "0.60.15"
-34
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 version = "1.10.0"
 version = "1.11.0"
-39
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["byte-stream-poll-next", "http-body-0-4-x"]
 version = "1.3.6"
 version = "1.4.0"
-44
 [dependencies.http-02x]
 package = "http"
 version = "0.2.9"
 version = "0.2.12"
-48
 [dependencies.http-1x]
 package = "http"
 version = "1"
 version = "1.3.1"
-52
 [dependencies.http-body-04x]
 package = "http-body"
 version = "0.4.5"
 version = "0.4.6"
-56
 [dependencies.futures-util]
 version = "0.3.29"
 default-features = false
-60
 [dev-dependencies]
 async-stream = "0.3"
 proptest = "1"
-64
 [dev-dependencies.futures-util]

↧ Expand context

 version = "0.3.29"
 default-features = false
-68
 [dev-dependencies.hyper]
 version = "0.14.26"
 features = ["stream"]
-72
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "rt", "rt-multi-thread"]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/fuzz/Cargo.toml

@@ -1,1 +27,27 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [[bin]]
 name = "read_many_from_str"
 path = "fuzz_targets/read_many_from_str.rs"
 test = false
 doc = false
-7
 [package]
 name = "aws-smithy-http-fuzz"
 version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
 edition = "2021"

-14
 [package.metadata]
 cargo-fuzz = true
-17
 [dependencies]
 libfuzzer-sys = "=0.4.7"
 http = "0.2.3"
-21
 [dependencies.aws-smithy-http]
 path = ".."
 version = "0.62.6"
 version = "0.63.0"
-25
 [workspace]
 members = ["."]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/src/event_stream/receiver.rs

@@ -1,1 +39,39 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use aws_smithy_eventstream::frame::{
     DecodedFrame, MessageFrameDecoder, UnmarshallMessage, UnmarshalledMessage,
 };
 use aws_smithy_runtime_api::client::result::{ConnectorError, SdkError};
 use aws_smithy_runtime_api::client::result::{ConnectorError, ResponseError, SdkError};
 use aws_smithy_types::body::SdkBody;
 use aws_smithy_types::event_stream::{Message, RawMessage};
 use bytes::Buf;
 use bytes::Bytes;
 use bytes_utils::SegmentedBuf;
 use std::error::Error as StdError;
 use std::fmt;
 use std::marker::PhantomData;
 use std::mem;
 use tracing::trace;

↧ Expand context

-20
 /// Wrapper around SegmentedBuf that tracks the state of the stream.
 #[derive(Debug)]
 enum RecvBuf {
     /// Nothing has been buffered yet.
     Empty,
     /// Some data has been buffered.
     /// The SegmentedBuf will automatically purge when it reads off the end of a chunk boundary.
     Partial(SegmentedBuf<Bytes>),
     /// The end of the stream has been reached, but there may still be some buffered data.
     EosPartial(SegmentedBuf<Bytes>),
     /// An exception terminated this stream.
     Terminated,
-33
+}
-34
 impl RecvBuf {
     /// Returns true if there's more buffered data.
     fn has_data(&self) -> bool {
         match self {
             RecvBuf::Empty | RecvBuf::Terminated => false,

@@ -202,202 +277,300 @@

↥ Expand context

-202
+                        )
                     })?
-204
+                {
                     trace!(message = ?message, "received complete event stream message");
                     return Ok(Some(message));
-207
+                }
-208
+            }
-209
             self.buffer_next_chunk().await?;
-211
+        }
         if self.buffer.has_data() {
             trace!(remaining_data = ?self.buffer, "data left over in the event stream response stream");
             let buf = self.buffer.buffered();
             return Err(SdkError::response_error(
                 ReceiverError {
                     kind: ReceiverErrorKind::UnexpectedEndOfStream,
                 },
                 RawMessage::invalid(Some(buf.copy_to_bytes(buf.remaining()))),
             ));
-221
+        }

         Ok(None)
-223
+    }
-224
     /// Tries to receive the initial response message that has `:event-type` of a given `message_type`.
     /// If a different event type is received, then it is buffered and `Ok(None)` is returned.
     #[doc(hidden)]
     pub async fn try_recv_initial(
         &mut self,
         message_type: InitialMessageType,
     ) -> Result<Option<Message>, SdkError<E, RawMessage>> {
         self.try_recv_initial_with_preprocessor(message_type, |msg| Ok((msg, ())))
             .await
             .map(|opt| opt.map(|(msg, _)| msg))
-+
+    }
-+
     /// Tries to receive the initial response message with preprocessing support.
     ///
     /// The preprocessor function can transform the raw message (e.g., unwrap envelopes)
     /// and return metadata alongside the transformed message. If the transformed message
     /// matches the expected `message_type`, both the message and metadata are returned.
     /// Otherwise, the transformed message is buffered and `Ok(None)` is returned.
     #[doc(hidden)]
     pub async fn try_recv_initial_with_preprocessor<F, M>(
         &mut self,
         message_type: InitialMessageType,
         preprocessor: F,
     ) -> Result<Option<(Message, M)>, SdkError<E, RawMessage>>
     where
         F: FnOnce(Message) -> Result<(Message, M), ResponseError<RawMessage>>,
-+
+    {
         if let Some(message) = self.next_message().await? {
             if let Some(event_type) = message
             let (processed_message, metadata) =
                 preprocessor(message.clone()).map_err(|err| SdkError::ResponseError(err))?;
-+
             if let Some(event_type) = processed_message
                 .headers()
                 .iter()
                 .find(|h| h.name().as_str() == ":event-type")
-260
+            {
                 if event_type
                     .value()
                     .as_string()
                     .map(|s| s.as_str() == message_type.as_str())
                     .unwrap_or(false)
-266
+                {
                     return Ok(Some(message));
                     return Ok(Some((processed_message, metadata)));
-268
+                }
-269
+            }
             // Buffer the message so that it can be returned by the next call to `recv()`
             // Buffer the processed message so that it can be returned by the next call to `recv()`
             self.buffered_message = Some(message);
-272
+        }
         Ok(None)
-274
+    }
-275
     /// Asynchronously tries to receive a message from the stream. If the stream has ended,
     /// it returns an `Ok(None)`. If there is a transport layer error, it will return
     /// `Err(SdkError::DispatchFailure)`. Service-modeled errors will be a part of the returned
     /// messages.
     pub async fn recv(&mut self) -> Result<Option<T>, SdkError<E, RawMessage>> {

↧ Expand context

         if let Some(buffered) = self.buffered_message.take() {
             return match self.unmarshall(buffered) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
-287
+                }
             };
-289
+        }
         if let Some(message) = self.next_message().await? {
             match self.unmarshall(message) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
-296
+                }
-297
+            }
         } else {
             Ok(None)
-300
+        }

@@ -429,452 +489,512 @@

↥ Expand context

             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(
             TestMessage("four".into()),
             receiver.recv().await.unwrap().unwrap()
         );
         assert_eq!(None, receiver.recv().await.unwrap());
-459
+    }
-460
     proptest::proptest! {
         #[test]
         fn receive_multiple_messages_split_unevenly_across_chunks(b1: usize, b2: usize) {
             let combined = Bytes::from([
                 encode_message("one"),
                 encode_message("two"),
                 encode_message("three"),
                 encode_message("four"),
                 encode_message("five"),
                 encode_message("six"),
                 encode_message("seven"),

                 encode_message("eight"),
             ].concat());
-474
             let midpoint = combined.len() / 2;
             let (start, boundary1, boundary2, end) = (
 ,
                 b1 % midpoint,
                 midpoint + b2 % midpoint,
                 combined.len()
             );
             println!("[{}, {}], [{}, {}], [{}, {}]", start, boundary1, boundary1, boundary2, boundary2, end);
             println!("[{start}, {boundary1}], [{boundary1}, {boundary2}], [{boundary2}, {end}]");
-483
             let rt = tokio::runtime::Runtime::new().unwrap();
             rt.block_on(async move {
                 let chunks: Vec<Result<_, IOError>> = vec![
                     Ok(Bytes::copy_from_slice(&combined[start..boundary1])),
                     Ok(Bytes::copy_from_slice(&combined[boundary1..boundary2])),
                     Ok(Bytes::copy_from_slice(&combined[boundary2..end])),
                 ];
-491
                 let chunk_stream = futures_util::stream::iter(chunks);

↧ Expand context

                 let body = SdkBody::from_body_0_4(Body::wrap_stream(chunk_stream));
                 let mut receiver = Receiver::<TestMessage, EventStreamError>::new(Unmarshaller, body);
                 for payload in &["one", "two", "three", "four", "five", "six", "seven", "eight"] {
                     assert_eq!(
                         TestMessage((*payload).into()),
                         receiver.recv().await.unwrap().unwrap()
                     );
-500
+                }
                 assert_eq!(None, receiver.recv().await.unwrap());
             });
-503
+        }
-504
+    }
-505
     #[tokio::test]
     async fn receive_network_failure() {
         let chunks: Vec<Result<_, IOError>> = vec![
             Ok(encode_message("one")),
             Err(IOError::new(ErrorKind::ConnectionReset, FakeError)),
         ];
         let chunk_stream = futures_util::stream::iter(chunks);

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-mocks/Cargo.toml

@@ -1,1 +0,45 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-mocks"
 version = "0.2.3"
 version = "0.2.4"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Testing utilities for smithy-rs generated clients"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [dependencies]
 http = "1"
 http = "1.3.1"
-19
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.6"
 version = "1.4.0"
-23
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x", "test-util"]
 version = "1.10.0"
 version = "1.11.0"
-28
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util"]
 version = "1.1.6"
 [dev-dependencies.tokio]
 version = "1"
 features = ["full"]
-36
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio"]
 version = "1.2.7"
 version = "1.2.8"
-41
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.9.8"
 version = "1.10.0"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability-otel/Cargo.toml

@@ -1,1 +49,49 @@

↥ Expand context

 [[bench]]
 name = "sync_instruments"
 harness = false
-5
 [[bench]]
 name = "async_instruments"
 harness = false
-9
 [package]
 name = "aws-smithy-observability-otel"
 version = "0.1.4"
 version = "0.1.5"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Smithy OpenTelemetry observability implementation."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/awslabs/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-24
 [dependencies]
 value-bag = "1.10.0"
 async-global-executor = "2.4.1"
 async-task = "=4.7.1"
-29
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.2.0"
 version = "0.2.1"
-33
 [dependencies.opentelemetry]
 version = "0.26.0"
 features = ["metrics"]
 [target."cfg(not(target_arch = \"powerpc\"))".dependencies.opentelemetry_sdk]
 version = "0.26.0"
 features = ["metrics", "testing"]
-40
 [dev-dependencies]
 stats_alloc = "0.1.10"

↧ Expand context

-43
 [dev-dependencies.tokio]
 version = "1.23.1"
-46
 [dev-dependencies.criterion]
 version = "0.5.1"
 features = ["async_tokio"]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/Cargo.toml

@@ -1,1 +21,21 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-observability"
 version = "0.2.0"
 version = "0.2.1"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Smithy observability implementation."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/awslabs/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.10.0"
 version = "1.11.0"
-19
 [dev-dependencies]
 serial_test = "3.1.1"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/Cargo.toml

@@ -1,1 +0,46 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-protocol-test"
 version = "0.63.7"
 version = "0.63.8"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "A collection of library functions to validate HTTP requests against Smithy protocol tests."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.88"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [features]
 default = ["http-02x"]
 http-02x = ["dep:http-0x"]
 http-1x = ["dep:http-1x"]
-+
 [dependencies]
 assert-json-diff = "2"
 base64-simd = "0.8"
 cbor-diag = "0.1.12"
 ciborium = "0.2"
 http = "0.2.9"
 pretty_assertions = "1.3"
 regex-lite = "0.1.5"
 roxmltree = "0.14.1"
 serde_json = "1.0.128"
 thiserror = "2"
-32
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.10.0"
 version = "1.11.0"
-+
 [dependencies.http-0x]
 package = "http"
 version = "0.2.12"
 optional = true
-+
 [dependencies.http-1x]
 package = "http"
 version = "1.3.1"
 optional = true

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/src/lib.rs

@@ -1,1 +54,53 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 /* Automatically managed default lints */
 #![cfg_attr(docsrs, feature(doc_cfg))]
 /* End of automatically managed default lints */
 #![warn(
     // missing_docs,
     // rustdoc::missing_crate_level_docs,
     unreachable_pub,
     rust_2018_idioms

 )]
-15
 mod urlencoded;
 mod xml;
-18
 use crate::sealed::GetNormalizedHeader;
 use crate::xml::try_xml_equivalent;
 use assert_json_diff::assert_json_matches_no_panic;
 use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
 use aws_smithy_runtime_api::http::Headers;
 use http::{HeaderMap, Uri};
 use pretty_assertions::Comparison;
 use std::borrow::Cow;
 use std::collections::HashSet;
 use std::fmt::{self, Debug};
 use thiserror::Error;
 use urlencoded::try_url_encoded_form_equivalent;
-30
 /// Helper trait for tests for float comparisons
 ///
 /// This trait differs in float's default `PartialEq` implementation by considering all `NaN` values to

↧ Expand context

 /// be equal.
 pub trait FloatEquals {
     fn float_equals(&self, other: &Self) -> bool;
-37
+}
-38
 impl FloatEquals for f64 {
     fn float_equals(&self, other: &Self) -> bool {
         (self.is_nan() && other.is_nan()) || self.eq(other)
-42
+    }
-43
+}
-44
 impl FloatEquals for f32 {
     fn float_equals(&self, other: &Self) -> bool {
         (self.is_nan() && other.is_nan()) || self.eq(other)
-48
+    }
-49
+}
-50
 impl<T> FloatEquals for Option<T>
 where
     T: FloatEquals,

@@ -119,118 +183,195 @@

↥ Expand context

     value: Option<&'a str>,
-119
+}
-120
 impl<'a> QueryParam<'a> {
     fn parse(s: &'a str) -> Self {
         let mut parsed = s.split('=');
         QueryParam {
             key: parsed.next().unwrap(),
             value: parsed.next(),
-127
+        }
-128
+    }
-129
+}
-130
 fn extract_params(uri: &str) -> HashSet<&str> {
     let query = uri.rsplit_once('?').map(|s| s.1).unwrap_or_default();
     query.split('&').collect()
-134
+}
-135
 #[track_caller]
 pub fn assert_uris_match(left: impl AsRef<str>, right: impl AsRef<str>) {

     let left = left.as_ref();
     let right = right.as_ref();
     if left == right {
         return;
-142
+    }
     assert_eq!(
         extract_params(left),
         extract_params(right),
         "Query parameters did not match. left: {left}, right: {right}"
     );
     let left: Uri = left.parse().expect("left is not a valid URI");
     let right: Uri = right.parse().expect("left is not a valid URI");
     assert_eq!(left.authority(), right.authority());
     assert_eq!(left.scheme(), right.scheme());
     assert_eq!(left.path(), right.path());
-+
     // When both features are enabled, prefer http-1x version
     #[cfg(feature = "http-1x")]
-+
+    {
         let left: http_1x::Uri = left.parse().expect("left is not a valid URI");
         let right: http_1x::Uri = right.parse().expect("right is not a valid URI");
         assert_eq!(left.authority(), right.authority());
         assert_eq!(left.scheme(), right.scheme());
         assert_eq!(left.path(), right.path());
-+
+    }
     #[cfg(all(feature = "http-02x", not(feature = "http-1x")))]
-+
+    {
         let left: http_0x::Uri = left.parse().expect("left is not a valid URI");
         let right: http_0x::Uri = right.parse().expect("right is not a valid URI");
         assert_eq!(left.authority(), right.authority());
         assert_eq!(left.scheme(), right.scheme());
         assert_eq!(left.path(), right.path());
-+
+    }
-166
+}
-167
 pub fn validate_query_string(
     request: &HttpRequest,
     expected_params: &[&str],
 ) -> Result<(), ProtocolTestFailure> {
     let actual_params = extract_params(request.uri());
     for param in expected_params {
         if !actual_params.contains(param) {
             return Err(ProtocolTestFailure::MissingQueryParam {

↧ Expand context

                 expected: param.to_string(),
                 found: actual_params.iter().map(|s| s.to_string()).collect(),
             });
-179
+        }
-180
+    }
     Ok(())
-182
+}
-183
 pub fn forbid_query_params(
     request: &HttpRequest,
     forbid_params: &[&str],
 ) -> Result<(), ProtocolTestFailure> {
     let actual_params: HashSet<QueryParam<'_>> = extract_params(request.uri())
         .iter()
         .map(|param| QueryParam::parse(param))
         .collect();
     let actual_keys: HashSet<&str> = actual_params.iter().map(|param| param.key).collect();
     for param in forbid_params {
         let parsed = QueryParam::parse(param);
         // If the forbidden param is k=v, then forbid this key-value pair

@@ -203,215 +263,295 @@

↥ Expand context

     let actual_keys: HashSet<&str> = extract_params(request.uri())
         .iter()
         .map(|param| QueryParam::parse(param).key)
         .collect();
     for key in require_keys {
         if !actual_keys.contains(*key) {
             return Err(ProtocolTestFailure::RequiredQueryParam {
                 expected: key.to_string(),
             });
-224
+        }
-225
+    }
     Ok(())
-227
+}
-228
 mod sealed {
     pub trait GetNormalizedHeader {
         fn get_header(&self, key: &str) -> Option<String>;
-232
+    }
-233
+}
-234

 impl GetNormalizedHeader for &Headers {
     fn get_header(&self, key: &str) -> Option<String> {
         if !self.contains_key(key) {
             None
         } else {
             Some(self.get_all(key).collect::<Vec<_>>().join(", "))
-241
+        }
-242
+    }
-243
+}
-244
 impl GetNormalizedHeader for &HeaderMap {
 // HTTP 0.2.x HeaderMap implementation
 #[cfg(feature = "http-02x")]
 impl GetNormalizedHeader for &http_0x::HeaderMap {
     fn get_header(&self, key: &str) -> Option<String> {
         if !self.contains_key(key) {
             None
         } else {
             Some(
                 self.get_all(key)
                     .iter()
                     .map(|value| std::str::from_utf8(value.as_bytes()).expect("invalid utf-8"))
                     .collect::<Vec<_>>()
                     .join(", "),
-+
+            )
-+
+        }
-+
+    }
-+
+}
-+
 // HTTP 1.x HeaderMap implementation
 #[cfg(feature = "http-1x")]
 impl GetNormalizedHeader for &http_1x::HeaderMap {
     fn get_header(&self, key: &str) -> Option<String> {
         if !self.contains_key(key) {
             None
         } else {
             Some(
                 self.get_all(key)
                     .iter()
                     .map(|value| std::str::from_utf8(value.as_bytes()).expect("invalid utf-8"))
                     .collect::<Vec<_>>()
                     .join(", "),

↧ Expand context

-276
+            )
-277
+        }
-278
+    }
-279
+}
-280
 pub fn validate_headers<'a>(
     actual_headers: impl GetNormalizedHeader,
     expected_headers: impl IntoIterator<Item = (impl AsRef<str> + 'a, impl AsRef<str> + 'a)>,
 ) -> Result<(), ProtocolTestFailure> {
     for (key, expected_value) in expected_headers {
         let key = key.as_ref();
         let expected_value = expected_value.as_ref();
         match actual_headers.get_header(key) {
             None => {
                 return Err(ProtocolTestFailure::MissingHeader {
                     expected: key.to_string(),
                 })
-293
+            }
             Some(actual_value) if actual_value != *expected_value => {
                 return Err(ProtocolTestFailure::InvalidHeader {

@@ -714,746 +764,800 @@

↥ Expand context

         validate_body(actual, expected_base64.as_str(), MediaType::Cbor)
             .expect_err("arrays in CBOR should follow strict ordering");
-748
+    }
-749
     #[test]
     fn test_validate_xml_body() {
         let expected = r#"<a>
         hello123
         </a>"#;
         let actual = "<a>hello123</a>";
         validate_body(actual, expected, MediaType::Xml).expect("inputs match as XML");
         let expected = r#"<a>
         hello123
         </a>"#;
         let actual = "<a>hello124</a>";
         validate_body(actual, expected, MediaType::Xml).expect_err("inputs are different");
-762
+    }
-763
     #[test]
     fn test_validate_non_json_body() {

         let expected = r#"asdf"#;
         let actual = r#"asdf "#;
         validate_body(actual, expected, MediaType::from("something/else"))
             .expect_err("bodies do not match");
-770
         validate_body(expected, expected, MediaType::from("something/else"))
             .expect("inputs matched exactly")
-773
+    }
-774
     #[test]
     #[cfg(feature = "http-02x")]
     fn test_validate_headers_http0x() {
         let request = http::Request::builder().header("a", "b").body(()).unwrap();
         let request = http_0x::Request::builder()
             .header("a", "b")
             .body(())
             .unwrap();
         validate_headers(request.headers(), [("a", "b")]).unwrap()
-783
+    }
-784
     #[test]
     fn test_float_equals() {
         let a = f64::NAN;
         let b = f64::NAN;
         assert_ne!(a, b);
         assert!(a.float_equals(&b));
         assert!(!a.float_equals(&5_f64));

↧ Expand context

-792
         assert!(5.0.float_equals(&5.0));
         assert!(!5.0.float_equals(&5.1));
-795
         assert!(f64::INFINITY.float_equals(&f64::INFINITY));
         assert!(!f64::INFINITY.float_equals(&f64::NEG_INFINITY));
         assert!(f64::NEG_INFINITY.float_equals(&f64::NEG_INFINITY));
-799
+    }
-800
+}

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/event_stream/receiver.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/header.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/label.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/query.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/query_writer.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-json/fuzz/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/fuzz/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/src/event_stream/receiver.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-mocks/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability-otel/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-protocol-test/src/lib.rs

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-query/Cargo.toml