aws_smithy_query/codec/

serializer.rs

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

use aws_smithy_schema::codec::FinishSerializer;
use aws_smithy_schema::extension::SchemaExtensionKey;
use aws_smithy_schema::serde::{SerdeError, SerializableStruct, ShapeSerializer};
use aws_smithy_schema::Schema;
use aws_smithy_types::{BigDecimal, BigInteger, Blob, DateTime, Document};
use std::fmt::Write;
use std::ops::Deref;
use std::sync::Arc;
use urlencoding::encode;

/// A collection path segment.
/// - `Index(i)` — a list element: renders as `i`.
/// - `Entry(i, name)` — a map key/value: renders as `i.name`.
#[derive(Clone, Copy)]
enum Segment<'a> {
    Index(usize),
    Entry(usize, &'a str),
}

impl std::fmt::Display for Segment<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Segment::Index(i) => write!(f, "{i}"),
            Segment::Entry(i, name) => write!(f, "{i}.{name}"),
        }
    }
}

/// A wire name held on the collection stack across serializer calls: a default, or
/// a name shared with the [`CollectionNames`] cached on a schema.
///
/// Cloning never allocates.
#[derive(Clone, Debug)]
enum Name {
    Static(&'static str),
    Shared(Arc<str>),
}

impl Deref for Name {
    type Target = str;

    fn deref(&self) -> &str {
        match self {
            Name::Static(name) => name,
            Name::Shared(name) => name,
        }
    }
}

/// The name of a collection's element (a list member or map value) or map key.
#[derive(Debug)]
enum ElementName {
    /// The collection has no element schema, as for the member-less placeholder
    /// codegen passes for a nested aggregate. Use the name inherited from the
    /// enclosing collection.
    Inherit,
    /// The element schema has neither `@xmlName` nor a member name.
    Default,
    Named(Name),
}

impl ElementName {
    fn of(element: Option<&Schema<'_>>) -> Self {
        match element {
            None => ElementName::Inherit,
            Some(element) => match wire_name(element) {
                Some(name) => ElementName::Named(name),
                None => ElementName::Default,
            },
        }
    }

    fn resolve(&self, inherited: Option<Name>, default: &'static str) -> Name {
        match self {
            ElementName::Named(name) => name.clone(),
            ElementName::Default => Name::Static(default),
            ElementName::Inherit => inherited.unwrap_or(Name::Static(default)),
        }
    }
}

/// `@xmlName`, then the member name, of an element schema.
fn wire_name(schema: &Schema<'_>) -> Option<Name> {
    schema
        .xml_name()
        .map(|name| name.value())
        .or(schema.member_name())
        .map(|name| Name::Shared(name.into()))
}

/// The wire names a list or map schema contributes to its elements' parameter
/// names, cached on the schema so that serializing a collection copies no names.
#[derive(Debug)]
struct CollectionNames {
    /// The list member or map value name.
    element: ElementName,
    /// The map key name.
    key: ElementName,
    /// Names for a nested aggregate element that arrives with a member-less
    /// placeholder schema (codegen passes `prelude::DOCUMENT` for nested
    /// aggregates): its own element (or value) and key names. They are recovered
    /// from this collection's element schema, mirroring the one-level recovery the
    /// XML serializer performs.
    nested_element: Option<Name>,
    nested_key: Option<Name>,
}

static COLLECTION_NAMES: SchemaExtensionKey<CollectionNames> = SchemaExtensionKey::new(|schema| {
    let element = schema.member();
    CollectionNames {
        element: ElementName::of(element),
        key: ElementName::of(schema.key()),
        nested_element: element.and_then(|e| e.member()).and_then(wire_name),
        nested_key: element.and_then(|e| e.key()).and_then(wire_name),
    }
});

enum CollectionContext {
    List {
        index: usize,
        /// See [`CollectionNames::nested_element`].
        inherited_member_name: Option<Name>,
        /// See [`CollectionNames::nested_key`].
        inherited_key_name: Option<Name>,
    },
    Map {
        index: usize,
        expecting_key: bool,
        key_name: Name,
        value_name: Name,
        /// See [`CollectionNames::nested_element`].
        inherited_member_name: Option<Name>,
        /// See [`CollectionNames::nested_key`].
        inherited_key_name: Option<Name>,
    },
}

/// Returns the path segment for the current collection element and advances the
/// cursor: a 1-based index for lists, `<index>.<key|value_name>` for maps. Returns
/// `None` when not inside a collection.
///
/// Takes the stack rather than the serializer so the segment, which borrows its
/// name from the stack, can be written into the serializer's other fields.
fn next_collection_segment(context_stack: &mut [CollectionContext]) -> Option<Segment<'_>> {
    let ctx = context_stack.last_mut()?;
    Some(match ctx {
        CollectionContext::List { index, .. } => {
            let seg = Segment::Index(*index);
            *index += 1;
            seg
        }
        CollectionContext::Map {
            index,
            expecting_key,
            key_name,
            value_name,
            ..
        } => {
            if *expecting_key {
                *expecting_key = false;
                Segment::Entry(*index, key_name)
            } else {
                let seg = Segment::Entry(*index, value_name);
                *expecting_key = true;
                *index += 1;
                seg
            }
        }
    })
}

/// Formats a [`Segment`] onto `prefix`, recording the previous length so it can be
/// popped, without an intermediate `String`.
fn push_prefix_segment(prefix: &mut String, prefix_lengths: &mut Vec<usize>, segment: Segment<'_>) {
    let prev_len = prefix.len();
    if !prefix.is_empty() {
        prefix.push('.');
    }
    // Writing to a String is infallible.
    let _ = write!(prefix, "{segment}");
    prefix_lengths.push(prev_len);
}

/// Serializes a request shape to the awsQuery `application/x-www-form-urlencoded` body.
///
/// Recurses through nested structs/lists/maps without a depth bound; this is safe
/// because the input is the client's own request shape, whose depth is fixed by the
/// model at codegen time (not attacker-controlled).
pub struct QueryShapeSerializer {
    output: String,
    prefix: String,
    prefix_lengths: Vec<usize>,
    context_stack: Vec<CollectionContext>,
}

impl QueryShapeSerializer {
    pub fn new(action: &str, version: &str) -> Self {
        let mut output = String::with_capacity(256);
        // Writing to a String is infallible.
        let _ = write!(
            output,
            "Action={}&Version={}",
            encode(action),
            encode(version)
        );
        Self {
            output,
            prefix: String::with_capacity(64),
            prefix_lengths: Vec::with_capacity(8),
            context_stack: Vec::with_capacity(4),
        }
    }

    fn wire_name<'a>(&self, schema: &'a Schema<'_>) -> &'a str {
        schema
            .xml_name()
            .map(|t| t.value())
            .or(schema.member_name())
            .unwrap_or("")
    }

    /// Names to hand a nested aggregate element/value that arrives with a
    /// member-less placeholder schema (codegen passes `prelude::DOCUMENT` for
    /// nested aggregates). The immediate parent collection resolves these from
    /// its element/value schema while it still holds the schema borrow and
    /// stashes them owned, so a nested `write_list`/`write_map` can recover its
    /// `@xmlName`/member names one level down. This mirrors the one-level
    /// recovery the XML serializer performs via its owned `list_item_name`.
    ///
    /// Returns `(inherited_member_name, inherited_key_name)` from the current
    /// top-of-stack collection, but only at a map's value position
    /// (`expecting_key == false`); map keys are always scalars.
    fn inherited_child_names(&self) -> (Option<Name>, Option<Name>) {
        match self.context_stack.last() {
            Some(CollectionContext::List {
                inherited_member_name,
                inherited_key_name,
                ..
            })
            | Some(CollectionContext::Map {
                expecting_key: false,
                inherited_member_name,
                inherited_key_name,
                ..
            }) => (inherited_member_name.clone(), inherited_key_name.clone()),
            _ => (None, None),
        }
    }

    fn push_prefix(&mut self, segment: &str) {
        let prev_len = self.prefix.len();
        if !self.prefix.is_empty() {
            self.prefix.push('.');
        }
        self.prefix.push_str(segment);
        self.prefix_lengths.push(prev_len);
    }

    fn pop_prefix(&mut self) {
        let prev_len = self.prefix_lengths.pop().expect("prefix stack underflow");
        self.prefix.truncate(prev_len);
    }

    /// Appends `&<param>=<value>` to the output, where `<param>` is `prefix` joined
    /// with either the collection segment (for an anonymous element) or the scalar's
    /// own wire name.
    fn write_scalar(&mut self, schema: &Schema<'_>, value: &str) -> Result<(), SerdeError> {
        let segment = if schema.member_name().is_none() {
            next_collection_segment(&mut self.context_stack)
        } else {
            None
        };
        self.output.push('&');
        // Writing to a String is infallible.
        match segment {
            Some(seg) => {
                let _ = write!(self.output, "{}.{}", self.prefix, seg);
            }
            None => {
                let name = self.wire_name(schema);
                // A named scalar written outside a collection must resolve to a
                // non-empty parameter name; an empty name would emit `&=value`
                // (or `&prefix.=value`), a malformed query param. In practice
                // codegen always supplies a member/xmlName here — this guards
                // against a future caller passing a member-less schema.
                debug_assert!(
                    !name.is_empty(),
                    "awsQuery scalar has no wire name (would emit an empty param name)"
                );
                if self.prefix.is_empty() {
                    self.output.push_str(name);
                } else {
                    let _ = write!(self.output, "{}.{}", self.prefix, name);
                }
            }
        }
        self.output.push('=');
        self.output.push_str(&encode(value));
        Ok(())
    }
}

impl FinishSerializer for QueryShapeSerializer {
    fn finish(self) -> Vec<u8> {
        self.output.into_bytes()
    }
}

impl ShapeSerializer for QueryShapeSerializer {
    fn write_struct(
        &mut self,
        schema: &Schema<'_>,
        value: &dyn SerializableStruct,
    ) -> Result<(), SerdeError> {
        let is_member = schema.member_name().is_some();
        let pushed_index = if is_member {
            self.push_prefix(self.wire_name(schema));
            false
        } else if let Some(seg) = next_collection_segment(&mut self.context_stack) {
            push_prefix_segment(&mut self.prefix, &mut self.prefix_lengths, seg);
            true
        } else {
            false
        };
        value.serialize_members(self)?;
        if is_member || pushed_index {
            self.pop_prefix();
        }
        Ok(())
    }

    fn write_list(
        &mut self,
        schema: &Schema<'_>,
        write_elements: &dyn Fn(&mut dyn ShapeSerializer) -> Result<(), SerdeError>,
    ) -> Result<(), SerdeError> {
        // Read any name inherited from the enclosing collection BEFORE
        // `next_collection_segment` mutates its cursor (a nested list arrives with
        // a member-less `prelude::DOCUMENT`; its real `@xmlName`/member name is
        // recovered from the parent here).
        let (inherited_member, _inherited_key) = self.inherited_child_names();
        let flat = schema.xml_flattened();
        let is_member = schema.member_name().is_some();
        let pushed_index = if is_member {
            self.push_prefix(self.wire_name(schema));
            false
        } else if let Some(seg) = next_collection_segment(&mut self.context_stack) {
            push_prefix_segment(&mut self.prefix, &mut self.prefix_lengths, seg);
            true
        } else {
            false
        };
        let names = schema.extension(&COLLECTION_NAMES);
        if !flat {
            // This list's element name: its own member info, else the name
            // inherited from the parent (member-less placeholder), else `member`.
            let member_name = names.element.resolve(inherited_member, "member");
            self.push_prefix(&member_name);
        }
        // Names to stash for a nested aggregate element (recovered one level down).
        self.context_stack.push(CollectionContext::List {
            index: 1,
            inherited_member_name: names.nested_element.clone(),
            inherited_key_name: names.nested_key.clone(),
        });
        let output_len_before = self.output.len();
        write_elements(self)?;
        let wrote_elements = self.output.len() > output_len_before;
        self.context_stack.pop();
        if !flat {
            self.pop_prefix();
        }
        if !wrote_elements && is_member {
            self.output.push('&');
            self.output.push_str(&self.prefix);
            self.output.push('=');
        }
        if is_member || pushed_index {
            self.pop_prefix();
        }
        Ok(())
    }

    fn write_map(
        &mut self,
        schema: &Schema<'_>,
        write_entries: &dyn Fn(&mut dyn ShapeSerializer) -> Result<(), SerdeError>,
    ) -> Result<(), SerdeError> {
        // Read inherited names BEFORE `next_collection_segment` mutates the
        // enclosing collection's cursor (a nested map arrives member-less;
        // recover its key/value names from the parent here).
        let (inherited_member, inherited_key) = self.inherited_child_names();
        let flat = schema.xml_flattened();
        let is_member = schema.member_name().is_some();
        let pushed_index = if is_member {
            self.push_prefix(self.wire_name(schema));
            false
        } else if let Some(seg) = next_collection_segment(&mut self.context_stack) {
            push_prefix_segment(&mut self.prefix, &mut self.prefix_lengths, seg);
            true
        } else {
            false
        };
        if !flat {
            self.push_prefix("entry");
        }
        // Key/value names: own member info, else inherited (member-less
        // placeholder), else the `key`/`value` defaults.
        let names = schema.extension(&COLLECTION_NAMES);
        // Names to stash for a nested aggregate map value (recovered one level down).
        self.context_stack.push(CollectionContext::Map {
            index: 1,
            expecting_key: true,
            key_name: names.key.resolve(inherited_key, "key"),
            value_name: names.element.resolve(inherited_member, "value"),
            inherited_member_name: names.nested_element.clone(),
            inherited_key_name: names.nested_key.clone(),
        });
        write_entries(self)?;
        self.context_stack.pop();
        if !flat {
            self.pop_prefix();
        }
        if is_member || pushed_index {
            self.pop_prefix();
        }
        Ok(())
    }

    fn write_string(&mut self, schema: &Schema<'_>, value: &str) -> Result<(), SerdeError> {
        self.write_scalar(schema, value)
    }

    fn write_boolean(&mut self, schema: &Schema<'_>, value: bool) -> Result<(), SerdeError> {
        self.write_scalar(schema, if value { "true" } else { "false" })
    }

    fn write_byte(&mut self, schema: &Schema<'_>, value: i8) -> Result<(), SerdeError> {
        self.write_scalar(schema, &value.to_string())
    }

    fn write_short(&mut self, schema: &Schema<'_>, value: i16) -> Result<(), SerdeError> {
        self.write_scalar(schema, &value.to_string())
    }

    fn write_integer(&mut self, schema: &Schema<'_>, value: i32) -> Result<(), SerdeError> {
        self.write_scalar(schema, &value.to_string())
    }

    fn write_long(&mut self, schema: &Schema<'_>, value: i64) -> Result<(), SerdeError> {
        self.write_scalar(schema, &value.to_string())
    }

    fn write_float(&mut self, schema: &Schema<'_>, value: f32) -> Result<(), SerdeError> {
        let s = if value.is_nan() {
            "NaN".to_string()
        } else if value == f32::INFINITY {
            "Infinity".to_string()
        } else if value == f32::NEG_INFINITY {
            "-Infinity".to_string()
        } else {
            aws_smithy_types::primitive::Encoder::from(value)
                .encode()
                .to_owned()
        };
        self.write_scalar(schema, &s)
    }

    fn write_double(&mut self, schema: &Schema<'_>, value: f64) -> Result<(), SerdeError> {
        let s = if value.is_nan() {
            "NaN".to_string()
        } else if value == f64::INFINITY {
            "Infinity".to_string()
        } else if value == f64::NEG_INFINITY {
            "-Infinity".to_string()
        } else {
            aws_smithy_types::primitive::Encoder::from(value)
                .encode()
                .to_owned()
        };
        self.write_scalar(schema, &s)
    }

    fn write_big_integer(
        &mut self,
        schema: &Schema<'_>,
        value: &BigInteger,
    ) -> Result<(), SerdeError> {
        self.write_scalar(schema, value.as_ref())
    }

    fn write_big_decimal(
        &mut self,
        schema: &Schema<'_>,
        value: &BigDecimal,
    ) -> Result<(), SerdeError> {
        self.write_scalar(schema, value.as_ref())
    }

    fn write_blob(&mut self, schema: &Schema<'_>, value: Blob) -> Result<(), SerdeError> {
        self.write_scalar(schema, &aws_smithy_types::base64::encode(value.as_ref()))
    }

    fn write_timestamp(&mut self, schema: &Schema<'_>, value: &DateTime) -> Result<(), SerdeError> {
        let format = if let Some(ts_trait) = schema.timestamp_format() {
            match ts_trait.format() {
                aws_smithy_schema::traits::TimestampFormat::EpochSeconds => {
                    aws_smithy_types::date_time::Format::EpochSeconds
                }
                aws_smithy_schema::traits::TimestampFormat::HttpDate => {
                    aws_smithy_types::date_time::Format::HttpDate
                }
                aws_smithy_schema::traits::TimestampFormat::DateTime => {
                    aws_smithy_types::date_time::Format::DateTime
                }
                other => {
                    return Err(SerdeError::unsupported(format!(
                        "unsupported timestamp format {other:?}"
                    )))
                }
            }
        } else {
            aws_smithy_types::date_time::Format::DateTime
        };
        let formatted = value
            .fmt(format)
            .map_err(|e| SerdeError::custom(format!("timestamp format error: {e}")))?;
        self.write_scalar(schema, &formatted)
    }

    fn write_document(&mut self, _: &Schema<'_>, _: &Document) -> Result<(), SerdeError> {
        Err(SerdeError::unsupported(
            "documents not supported in awsQuery",
        ))
    }

    fn write_null(&mut self, _: &Schema<'_>) -> Result<(), SerdeError> {
        // awsQuery has no null representation: nulls are omitted. The collection
        // index is not advanced here (only emitted elements consume an index), so a
        // `@sparse` null is dropped rather than reserving a positional slot.
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use aws_smithy_schema::{shape_id, ShapeType};

    static NAME_MEMBER: Schema<'static> =
        Schema::new_member(shape_id!("test", "Input"), ShapeType::String, "Name", 0);
    static AGE_MEMBER: Schema<'static> =
        Schema::new_member(shape_id!("test", "Input"), ShapeType::Integer, "Age", 1);
    static INPUT_SCHEMA: Schema<'static> = Schema::new_struct(
        shape_id!("test", "Input"),
        ShapeType::Structure,
        &[&NAME_MEMBER, &AGE_MEMBER],
    );

    struct SimpleInput;
    impl SerializableStruct for SimpleInput {
        fn schema(&self) -> &Schema<'_> {
            &INPUT_SCHEMA
        }

        fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
            s.write_string(&NAME_MEMBER, "Alice")?;
            s.write_integer(&AGE_MEMBER, 30)
        }
    }

    #[test]
    fn simple_struct() {
        let mut ser = QueryShapeSerializer::new("GetUser", "2012-11-05");
        ser.write_struct(&INPUT_SCHEMA, &SimpleInput).unwrap();
        let output = String::from_utf8(ser.finish()).unwrap();
        assert_eq!(
            output,
            "Action=GetUser&Version=2012-11-05&Name=Alice&Age=30"
        );
    }

    #[test]
    fn boolean_values() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Boolean, "Verbose", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_boolean(&M, true).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Verbose=true"
        );
    }

    #[test]
    fn string_encoding() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Message", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_string(&M, "hello world&foo=bar").unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Message=hello%20world%26foo%3Dbar"
        );
    }

    #[test]
    fn nested_struct() {
        static INNER_FIELD: Schema<'static> =
            Schema::new_member(shape_id!("test", "Inner"), ShapeType::String, "Value", 0);
        static OUTER_MEMBER: Schema<'static> = Schema::new_member(
            shape_id!("test", "Outer"),
            ShapeType::Structure,
            "Config",
            0,
        );

        struct Inner;
        impl SerializableStruct for Inner {
            fn schema(&self) -> &Schema<'_> {
                static SCHEMA: Schema<'static> = Schema::new_struct(
                    aws_smithy_schema::shape_id!("test", "Inner"),
                    aws_smithy_schema::ShapeType::Structure,
                    &[&INNER_FIELD],
                );
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&INNER_FIELD, "hello")
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_struct(&OUTER_MEMBER, &Inner).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Config.Value=hello"
        );
    }

    #[test]
    fn list_non_flat() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "foo")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "bar")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Items.member.1=foo&Items.member.2=bar"
        );
    }

    #[test]
    fn list_flat() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0)
                .with_xml_flattened();
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "A")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "B")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Items.1=A&Items.2=B"
        );
    }

    #[test]
    fn list_of_integers() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Ids", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_integer(&aws_smithy_schema::prelude::INTEGER, 10)?;
            s.write_integer(&aws_smithy_schema::prelude::INTEGER, 20)?;
            s.write_integer(&aws_smithy_schema::prelude::INTEGER, 30)
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Ids.member.1=10&Ids.member.2=20&Ids.member.3=30"
        );
    }

    #[test]
    fn map_non_flat() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "Tags", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "color")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "red")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "size")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "large")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0\
             &Tags.entry.1.key=color&Tags.entry.1.value=red\
             &Tags.entry.2.key=size&Tags.entry.2.value=large"
        );
    }

    #[test]
    fn list_non_flat_uses_renamed_member_name() {
        // @xmlName on the list's inner member schema (attached via
        // with_list_member, exactly as codegen's emitAggregateMemberChain
        // does) drives the repeated element name — no protocol-specific
        // schema field required. Mirrors the AWS REST XML serializer.
        static ITEM: Schema<'static> = Schema::new_member(
            shape_id!("test", "L$member"),
            ShapeType::String,
            "member",
            0,
        )
        .with_xml_name("Item");
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0)
                .with_list_member(&ITEM);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "foo")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "bar")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Items.Item.1=foo&Items.Item.2=bar"
        );
    }

    #[test]
    fn map_non_flat_uses_renamed_key_value_names() {
        // @xmlName on the map's key/value member schemas (attached via
        // with_map_members) drives the entry key/value element names.
        static KEY: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$key"), ShapeType::String, "key", 0)
                .with_xml_name("Attribute");
        static VALUE: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$value"), ShapeType::String, "value", 1)
                .with_xml_name("Setting");
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "Tags", 0)
                .with_map_members(&KEY, &VALUE);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "color")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "red")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Tags.entry.1.Attribute=color&Tags.entry.1.Setting=red"
        );
    }

    #[test]
    fn map_flat() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "Tags", 0)
                .with_xml_flattened();
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "k1")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "v1")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Tags.1.key=k1&Tags.1.value=v1"
        );
    }
}

#[cfg(test)]
mod cross_validation {
    use super::*;
    use crate::QueryWriter;
    use aws_smithy_schema::{shape_id, ShapeType};

    #[test]
    fn matches_query_writer_simple_params() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "SomeAction", "1.0");
        writer.prefix("Name").string("Alice");
        writer
            .prefix("Age")
            .number(aws_smithy_types::Number::PosInt(30));
        writer.finish();

        static NAME: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Name", 0);
        static AGE: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Integer, "Age", 1);
        static SCHEMA: Schema<'static> =
            Schema::new_struct(shape_id!("test", "I"), ShapeType::Structure, &[&NAME, &AGE]);
        struct Input;
        impl SerializableStruct for Input {
            fn schema(&self) -> &Schema<'_> {
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&NAME, "Alice")?;
                s.write_integer(&AGE, 30)
            }
        }

        let mut ser = QueryShapeSerializer::new("SomeAction", "1.0");
        ser.write_struct(&SCHEMA, &Input).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn matches_query_writer_list() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        let mut list = writer.prefix("ListArg").start_list(false, None);
        list.entry().string("foo");
        list.entry().string("bar");
        list.entry().string("baz");
        list.finish();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "ListArg", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "foo")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "bar")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "baz")
        })
        .unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn matches_query_writer_flat_list() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        let mut list = writer.prefix("FlatList").start_list(true, None);
        list.entry().string("A");
        list.entry().string("B");
        list.finish();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "FlatList", 0)
                .with_xml_flattened();
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "A")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "B")
        })
        .unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn matches_query_writer_map() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        let mut map = writer.prefix("MapArg").start_map(false, "key", "value");
        map.entry("bar").string("Bar");
        map.entry("foo").string("Foo");
        map.finish();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "MapArg", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "bar")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "Bar")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "foo")?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "Foo")
        })
        .unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn matches_query_writer_nested_prefix() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("first").prefix("second").string("val");
        writer.finish();

        static SECOND: Schema<'static> =
            Schema::new_member(shape_id!("test", "Inner"), ShapeType::String, "second", 0);
        static FIRST: Schema<'static> =
            Schema::new_member(shape_id!("test", "Outer"), ShapeType::Structure, "first", 0);

        struct Inner;
        impl SerializableStruct for Inner {
            fn schema(&self) -> &Schema<'_> {
                static SCHEMA: Schema<'static> = Schema::new_struct(
                    aws_smithy_schema::shape_id!("test", "Inner"),
                    aws_smithy_schema::ShapeType::Structure,
                    &[&SECOND],
                );
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&SECOND, "val")
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_struct(&FIRST, &Inner).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn nested_renamed_inner_list_member_matches_legacy() {
        // Regression: a `map<string, list<string>>` whose inner list member has
        // `@xmlName("item")`. Codegen invokes the inner `write_list` with a
        // member-less `prelude::DOCUMENT`, so the rename must be recovered from
        // the outer map's value-member schema (stashed as an owned inherited
        // name). Previously this fell back to "member"; now it must honor "item"
        // and match the legacy `QueryWriter`.
        static INNER_MEMBER: Schema<'static> = Schema::new_member(
            shape_id!("test", "L$member"),
            ShapeType::String,
            "member",
            0,
        )
        .with_xml_name("item");
        // The map's value member is a list carrying the renamed inner member.
        static VALUE_LIST: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$value"), ShapeType::List, "value", 1)
                .with_list_member(&INNER_MEMBER);
        static KEY: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$key"), ShapeType::String, "key", 0);
        static OUTER_MAP: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "MapOfLists", 0)
                .with_map_members(&KEY, &VALUE_LIST);

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&OUTER_MAP, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "bar")?;
            // codegen emits `write_list(&prelude::DOCUMENT, ..)` for the inner list
            s.write_list(&aws_smithy_schema::prelude::DOCUMENT, &|inner| {
                inner.write_string(&aws_smithy_schema::prelude::STRING, "C")?;
                inner.write_string(&aws_smithy_schema::prelude::STRING, "D")
            })
        })
        .unwrap();
        let schema_out = String::from_utf8(ser.finish()).unwrap();

        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        let mut map = writer.prefix("MapOfLists").start_map(false, "key", "value");
        {
            let mut list = map.entry("bar").start_list(false, Some("item"));
            list.entry().string("C");
            list.entry().string("D");
            list.finish();
        }
        map.finish();
        writer.finish();

        assert_eq!(schema_out, expected);
        assert_eq!(
            schema_out,
            "Action=Op&Version=1.0&MapOfLists.entry.1.key=bar\
             &MapOfLists.entry.1.value.item.1=C\
             &MapOfLists.entry.1.value.item.2=D"
        );
    }

    #[test]
    fn nested_renamed_inner_map_members_matches_legacy() {
        // Same fix for a `map<string, map<string, string>>` whose INNER map has
        // `@xmlName` on its key/value members. The inner `write_map` gets
        // `prelude::DOCUMENT`; the key/value renames come from the outer map's
        // value-member schema.
        static INNER_KEY: Schema<'static> =
            Schema::new_member(shape_id!("test", "IM$key"), ShapeType::String, "key", 0)
                .with_xml_name("K");
        static INNER_VALUE: Schema<'static> =
            Schema::new_member(shape_id!("test", "IM$value"), ShapeType::String, "value", 1)
                .with_xml_name("V");
        // Outer map value member is itself a map with renamed key/value.
        static VALUE_MAP: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$value"), ShapeType::Map, "value", 1)
                .with_map_members(&INNER_KEY, &INNER_VALUE);
        static OUTER_KEY: Schema<'static> =
            Schema::new_member(shape_id!("test", "M$key"), ShapeType::String, "key", 0);
        static OUTER_MAP: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "MapOfMaps", 0)
                .with_map_members(&OUTER_KEY, &VALUE_MAP);

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&OUTER_MAP, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "outer")?;
            s.write_map(&aws_smithy_schema::prelude::DOCUMENT, &|inner| {
                inner.write_string(&aws_smithy_schema::prelude::STRING, "ik")?;
                inner.write_string(&aws_smithy_schema::prelude::STRING, "iv")
            })
        })
        .unwrap();
        let schema_out = String::from_utf8(ser.finish()).unwrap();

        assert_eq!(
            schema_out,
            "Action=Op&Version=1.0&MapOfMaps.entry.1.key=outer\
             &MapOfMaps.entry.1.value.entry.1.K=ik\
             &MapOfMaps.entry.1.value.entry.1.V=iv"
        );
    }
}

#[cfg(test)]
mod edge_cases {
    use super::*;
    use crate::QueryWriter;
    use aws_smithy_schema::{shape_id, ShapeType};

    #[test]
    fn empty_string_value() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("Empty").string("");
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Empty", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_string(&M, "").unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn empty_non_flat_list_emits_bare_param() {
        // An empty list serializes to just `<prefix>=`; cross-checked against the legacy writer.
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("myList").start_list(false, None).finish();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "myList", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|_| Ok(())).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
        assert_eq!(expected, "Action=Op&Version=1.0&myList=");
    }

    #[test]
    fn empty_flat_list_emits_bare_param() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("myList").start_list(true, None).finish();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "myList", 0)
                .with_xml_flattened();
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|_| Ok(())).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
        assert_eq!(expected, "Action=Op&Version=1.0&myList=");
    }

    #[test]
    fn empty_list_does_not_alias_single_empty_string_element() {
        // Guards the `wrote_elements` length-delta heuristic in `write_list`: an empty
        // list (`myList=`) must not produce the same output as a one-empty-string-element
        // list (`myList.member.1=`).
        static EMPTY: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "myList", 0);
        let mut empty_ser = QueryShapeSerializer::new("Op", "1.0");
        empty_ser.write_list(&EMPTY, &|_| Ok(())).unwrap();
        let empty_out = String::from_utf8(empty_ser.finish()).unwrap();

        static ONE: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "myList", 0);
        let mut one_ser = QueryShapeSerializer::new("Op", "1.0");
        one_ser
            .write_list(&ONE, &|s| {
                s.write_string(&aws_smithy_schema::prelude::STRING, "")
            })
            .unwrap();
        let one_out = String::from_utf8(one_ser.finish()).unwrap();

        assert_eq!(empty_out, "Action=Op&Version=1.0&myList=");
        assert_eq!(one_out, "Action=Op&Version=1.0&myList.member.1=");
        assert_ne!(empty_out, one_out);
    }

    #[test]
    fn sparse_null_list_element_is_dropped_and_index_reflects_emitted_only() {
        // A null element is dropped without consuming an index, so the next real
        // element takes `.2` rather than `.3`.
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&M, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "a")?;
            s.write_null(&aws_smithy_schema::prelude::STRING)?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "b")
        })
        .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Items.member.1=a&Items.member.2=b"
        );
    }

    #[test]
    fn special_characters() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("Val").string("a=b&c<d>e\"f");
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Val", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_string(&M, "a=b&c<d>e\"f").unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn unicode_value() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("Name").string("日本語");
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Name", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_string(&M, "日本語").unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn timestamp_epoch_seconds() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer
            .prefix("Time")
            .date_time(
                &aws_smithy_types::DateTime::from_secs(1700000000),
                aws_smithy_types::date_time::Format::DateTime,
            )
            .unwrap();
        writer.finish();

        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Timestamp, "Time", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_timestamp(&M, &aws_smithy_types::DateTime::from_secs(1700000000))
            .unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn deeply_nested_struct() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("A").prefix("B").prefix("C").string("deep");
        writer.finish();

        static C_FIELD: Schema<'static> =
            Schema::new_member(shape_id!("t", "C"), ShapeType::String, "C", 0);
        static B_MEMBER: Schema<'static> =
            Schema::new_member(shape_id!("t", "B"), ShapeType::Structure, "B", 0);
        static A_MEMBER: Schema<'static> =
            Schema::new_member(shape_id!("t", "A"), ShapeType::Structure, "A", 0);

        struct CStruct;
        impl SerializableStruct for CStruct {
            fn schema(&self) -> &Schema<'_> {
                static SCHEMA: Schema<'static> = Schema::new_struct(
                    aws_smithy_schema::shape_id!("t", "C"),
                    aws_smithy_schema::ShapeType::Structure,
                    &[&C_FIELD],
                );
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&C_FIELD, "deep")
            }
        }
        struct BStruct;
        impl SerializableStruct for BStruct {
            fn schema(&self) -> &Schema<'_> {
                static SCHEMA: Schema<'static> = Schema::new_struct(
                    aws_smithy_schema::shape_id!("t", "B"),
                    aws_smithy_schema::ShapeType::Structure,
                    &[&B_MEMBER],
                );
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_struct(&B_MEMBER, &CStruct)
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_struct(&A_MEMBER, &BStruct).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn list_inside_struct() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        let mut outer = writer.prefix("Outer");
        let mut list = outer.prefix("Items").start_list(false, None);
        list.entry().string("x");
        list.entry().string("y");
        list.finish();
        writer.finish();

        static ITEMS: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::List, "Items", 0);
        static OUTER: Schema<'static> =
            Schema::new_member(shape_id!("t", "T"), ShapeType::Structure, "Outer", 0);

        struct Inner;
        impl SerializableStruct for Inner {
            fn schema(&self) -> &Schema<'_> {
                static SCHEMA: Schema<'static> = Schema::new_struct(
                    aws_smithy_schema::shape_id!("t", "T"),
                    aws_smithy_schema::ShapeType::Structure,
                    &[&ITEMS],
                );
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_list(&ITEMS, &|s| {
                    s.write_string(&aws_smithy_schema::prelude::STRING, "x")?;
                    s.write_string(&aws_smithy_schema::prelude::STRING, "y")
                })
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_struct(&OUTER, &Inner).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn multiple_fields_with_list_and_scalar() {
        let mut expected = String::new();
        let mut writer = QueryWriter::new(&mut expected, "Op", "1.0");
        writer.prefix("Name").string("Alice");
        let mut list = writer.prefix("Tags").start_list(false, None);
        list.entry().string("admin");
        list.entry().string("user");
        list.finish();
        writer
            .prefix("Age")
            .number(aws_smithy_types::Number::PosInt(30));
        writer.finish();

        static NAME: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::String, "Name", 0);
        static TAGS: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::List, "Tags", 1);
        static AGE: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::Integer, "Age", 2);
        static SCHEMA: Schema<'static> = Schema::new_struct(
            shape_id!("t", "S"),
            ShapeType::Structure,
            &[&NAME, &TAGS, &AGE],
        );

        struct Input;
        impl SerializableStruct for Input {
            fn schema(&self) -> &Schema<'_> {
                &SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&NAME, "Alice")?;
                s.write_list(&TAGS, &|s| {
                    s.write_string(&aws_smithy_schema::prelude::STRING, "admin")?;
                    s.write_string(&aws_smithy_schema::prelude::STRING, "user")
                })?;
                s.write_integer(&AGE, 30)
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_struct(&SCHEMA, &Input).unwrap();
        assert_eq!(String::from_utf8(ser.finish()).unwrap(), expected);
    }

    #[test]
    fn list_of_struct_emits_per_element_index() {
        static NAME: Schema<'static> =
            Schema::new_member(shape_id!("test", "Item"), ShapeType::String, "Name", 0);
        static ITEM_SCHEMA: Schema<'static> =
            Schema::new_struct(shape_id!("test", "Item"), ShapeType::Structure, &[&NAME]);
        static ITEMS_LIST: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0);

        struct Item(&'static str);
        impl SerializableStruct for Item {
            fn schema(&self) -> &Schema<'_> {
                &ITEM_SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&NAME, self.0)
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&ITEMS_LIST, &|s| {
            s.write_struct(&ITEM_SCHEMA, &Item("X1"))?;
            s.write_struct(&ITEM_SCHEMA, &Item("X2"))
        })
        .unwrap();

        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Items.member.1.Name=X1&Items.member.2.Name=X2",
        );
    }

    #[test]
    fn list_of_list() {
        static OUTER: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Outer", 0);
        static INNER_LIST: Schema<'static> = Schema::new_list(
            shape_id!("test", "InnerList"),
            &aws_smithy_schema::prelude::STRING,
        );

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&OUTER, &|s_outer| {
            s_outer.write_list(&INNER_LIST, &|s_inner| {
                s_inner.write_string(&aws_smithy_schema::prelude::STRING, "a")?;
                s_inner.write_string(&aws_smithy_schema::prelude::STRING, "b")
            })?;
            s_outer.write_list(&INNER_LIST, &|s_inner| {
                s_inner.write_string(&aws_smithy_schema::prelude::STRING, "c")
            })
        })
        .unwrap();

        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0\
             &Outer.member.1.member.1=a\
             &Outer.member.1.member.2=b\
             &Outer.member.2.member.1=c",
        );
    }

    #[test]
    fn map_of_struct_emits_per_entry_index() {
        static NAME: Schema<'static> =
            Schema::new_member(shape_id!("test", "Val"), ShapeType::String, "Name", 0);
        static VAL_SCHEMA: Schema<'static> =
            Schema::new_struct(shape_id!("test", "Val"), ShapeType::Structure, &[&NAME]);
        static MAP_MEMBER: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Map, "Things", 0);

        struct Val(&'static str);
        impl SerializableStruct for Val {
            fn schema(&self) -> &Schema<'_> {
                &VAL_SCHEMA
            }

            fn serialize_members(&self, s: &mut dyn ShapeSerializer) -> Result<(), SerdeError> {
                s.write_string(&NAME, self.0)
            }
        }

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_map(&MAP_MEMBER, &|s| {
            s.write_string(&aws_smithy_schema::prelude::STRING, "k1")?;
            s.write_struct(&VAL_SCHEMA, &Val("v1"))?;
            s.write_string(&aws_smithy_schema::prelude::STRING, "k2")?;
            s.write_struct(&VAL_SCHEMA, &Val("v2"))
        })
        .unwrap();

        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0\
             &Things.entry.1.key=k1&Things.entry.1.value.Name=v1\
             &Things.entry.2.key=k2&Things.entry.2.value.Name=v2",
        );
    }

    #[test]
    fn map_nested_in_list() {
        static MAP_SCHEMA: Schema<'static> = Schema::new_map(
            shape_id!("test", "M"),
            &aws_smithy_schema::prelude::STRING,
            &aws_smithy_schema::prelude::STRING,
        );
        static OUTER: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::List, "Items", 0);

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_list(&OUTER, &|s| {
            s.write_map(&MAP_SCHEMA, &|m| {
                m.write_string(&aws_smithy_schema::prelude::STRING, "k1")?;
                m.write_string(&aws_smithy_schema::prelude::STRING, "v1")
            })?;
            s.write_map(&MAP_SCHEMA, &|m| {
                m.write_string(&aws_smithy_schema::prelude::STRING, "k2")?;
                m.write_string(&aws_smithy_schema::prelude::STRING, "v2")
            })
        })
        .unwrap();

        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0\
             &Items.member.1.entry.1.key=k1&Items.member.1.entry.1.value=v1\
             &Items.member.2.entry.1.key=k2&Items.member.2.entry.1.value=v2",
        );
    }

    #[test]
    fn float_whole_number_keeps_decimal() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Float, "Val", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_double(&M, 5.0).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=5.0"
        );
    }

    #[test]
    fn float_special_values() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Float, "Val", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_float(&M, f32::INFINITY).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=Infinity"
        );

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_float(&M, f32::NEG_INFINITY).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=-Infinity"
        );

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_float(&M, f32::NAN).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=NaN"
        );
    }

    #[test]
    fn double_special_values() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Double, "Val", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_double(&M, f64::INFINITY).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=Infinity"
        );

        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_double(&M, f64::NEG_INFINITY).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Val=-Infinity"
        );
    }

    #[test]
    fn blob_base64_encoded() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Blob, "Data", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_blob(&M, aws_smithy_types::Blob::new(&b"hello"[..]))
            .unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&Data=aGVsbG8%3D"
        );
    }

    #[test]
    fn document_returns_error() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::Document, "Doc", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        let result = ser.write_document(&M, &Document::Null);
        assert!(result.is_err());
    }

    #[test]
    fn write_null_is_noop() {
        static M: Schema<'static> =
            Schema::new_member(shape_id!("test", "I"), ShapeType::String, "Val", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_null(&M).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0"
        );
    }

    #[test]
    fn numeric_types() {
        static B: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::Byte, "B", 0);
        static S: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::Short, "S", 0);
        static L: Schema<'static> =
            Schema::new_member(shape_id!("t", "S"), ShapeType::Long, "L", 0);
        let mut ser = QueryShapeSerializer::new("Op", "1.0");
        ser.write_byte(&B, -1).unwrap();
        ser.write_short(&S, 32000).unwrap();
        ser.write_long(&L, 9999999999).unwrap();
        assert_eq!(
            String::from_utf8(ser.finish()).unwrap(),
            "Action=Op&Version=1.0&B=-1&S=32000&L=9999999999"
        );
    }
}