/rust/registry/src/index.crates.io-1949cf8c6b5b557f/csv-1.4.0/src/serializer.rs

Source
use std::{fmt, io, mem};

use serde_core::ser::{
    Error as SerdeError, Serialize, SerializeMap, SerializeSeq,
    SerializeStruct, SerializeStructVariant, SerializeTuple,
    SerializeTupleStruct, SerializeTupleVariant, Serializer,
};

use crate::{
    error::{Error, ErrorKind},
    writer::Writer,
};

/// Serialize the given value to the given writer, and return an error if
/// anything went wrong.
pub fn serialize<S: Serialize, W: io::Write>(
    wtr: &mut Writer<W>,
    value: S,
) -> Result<(), Error> {
    value.serialize(&mut SeRecord { wtr })
}

struct SeRecord<'w, W: 'w + io::Write> {
    wtr: &'w mut Writer<W>,
}

impl<'a, 'w, W: io::Write> Serializer for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = Self;
    type SerializeTuple = Self;
    type SerializeTupleStruct = Self;
    type SerializeTupleVariant = Self;
    type SerializeMap = Self;
    type SerializeStruct = Self;
    type SerializeStructVariant = Self;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        if v {
            self.wtr.write_field("true")
        } else {
            self.wtr.write_field("false")
        }
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        let mut buffer = itoa::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        let mut buffer = ryu::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        let mut buffer = ryu::Buffer::new();
        self.wtr.write_field(buffer.format(v))
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field(v.encode_utf8(&mut [0; 4]))
    }

    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field(value)
    }

    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field(value)
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field([])
    }

    fn serialize_some<T: ?Sized + Serialize>(
        self,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        value.serialize(self)
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        None::<()>.serialize(self)
    }

    fn serialize_unit_struct(
        self,
        name: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field(name)
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.wtr.write_field(variant)
    }

    fn serialize_newtype_struct<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        value.serialize(self)
    }

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        value.serialize(self)
    }

    fn serialize_seq(
        self,
        _len: Option<usize>,
    ) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(self)
    }

    fn serialize_tuple(
        self,
        _len: usize,
    ) -> Result<Self::SerializeTuple, Self::Error> {
        Ok(self)
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        Ok(self)
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(Error::custom("serializing enum tuple variants is not supported"))
    }

    fn serialize_map(
        self,
        _len: Option<usize>,
    ) -> Result<Self::SerializeMap, Self::Error> {
        // The right behavior for serializing maps isn't clear.
        Err(Error::custom(
            "serializing maps is not supported, \
             if you have a use case, please file an issue at \
             https://github.com/BurntSushi/rust-csv",
        ))
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(self)
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(Error::custom("serializing enum struct variants is not supported"))
    }
}

impl<'a, 'w, W: io::Write> SerializeSeq for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTuple for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTupleStruct for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTupleVariant for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl<'a, 'w, W: io::Write> SerializeMap for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized + Serialize>(
        &mut self,
        _key: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn serialize_value<T: ?Sized + Serialize>(
        &mut self,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl<'a, 'w, W: io::Write> SerializeStruct for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        _key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeStructVariant for &'a mut SeRecord<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        _key: &'static str,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl SerdeError for Error {
    fn custom<T: fmt::Display>(msg: T) -> Error {
        Error::new(ErrorKind::Serialize(msg.to_string()))
    }
}

fn error_scalar_outside_struct<T: fmt::Display>(name: T) -> Error {
    Error::custom(format!(
        "cannot serialize {} scalar outside struct \
         when writing headers from structs",
        name
    ))
}

fn error_container_inside_struct<T: fmt::Display>(name: T) -> Error {
    Error::custom(format!(
        "cannot serialize {} container inside struct \
         when writing headers from structs",
        name
    ))
}

/// Write header names corresponding to the field names of the value (if the
/// value has field names).
///
/// If the type to be serialized has field names (e.g. it's a struct), then
/// header names are written, and the `Ok` return value is `true`.
///
/// If the type to be serialized doesn't have field names, then nothing is
/// written, and the `Ok` return value is `false`.
pub fn serialize_header<S: Serialize, W: io::Write>(
    wtr: &mut Writer<W>,
    value: S,
) -> Result<bool, Error> {
    let mut ser = SeHeader::new(wtr);
    value.serialize(&mut ser).map(|_| ser.wrote_header())
}

/// State machine for `SeHeader`.
///
/// This is a diagram of the transitions in the state machine. Note that only
/// some serialization events cause a state transition, and only for certain
/// states. For example, encountering a scalar causes a transition if the state
/// is `Write` or `EncounteredStructField`, but not if the state is
/// `ErrorIfWrite(err)` or `InStructField`.
///
/// ```text
///                              +-----+
///                              |Write|
///                              +-----+
///                                 |
///              /------------------+------------------\
///              |                  |                  |
///          encounter            finish           encounter
///            scalar               |             struct field
///              |                  |                  |
///              v                  v                  v
///     +-----------------+       Ok(())        +-------------+
///     |ErrorIfWrite(err)|                     |InStructField|<--------\
///     +-----------------+                     +-------------+         |
///              |                                     |                |
///       /------+------\            /-----------------+                |
///       |             |            |                 |                |
///   encounter       finish     encounter          finish          encounter
///  struct field       |        container           field         struct field
///       |             |            |                 |                |
///       v             v            v                 v                |
///   Err(err)       Ok(())        Err(_)   +----------------------+    |
///                                         |EncounteredStructField|    |
///                                         +----------------------+    |
///                                                    |                |
///                                         /----------+----------------/
///                                         |          |
///                                     encounter    finish
///                                       scalar       |
///                                         |          |
///                                         v          v
///                                       Err(_)    Ok(())
/// ```
enum HeaderState {
    /// Start here. Headers need to be written if the type has field names.
    Write,
    /// The serializer still has not encountered a struct field. If one is
    /// encountered (headers need to be written), return the enclosed error.
    ErrorIfWrite(Error),
    /// The serializer encountered one or more struct fields (and wrote their
    /// names).
    EncounteredStructField,
    /// The serializer is currently in a struct field value.
    InStructField,
}

struct SeHeader<'w, W: 'w + io::Write> {
    wtr: &'w mut Writer<W>,
    state: HeaderState,
}

impl<'w, W: io::Write> SeHeader<'w, W> {
    fn new(wtr: &'w mut Writer<W>) -> Self {
        SeHeader { wtr, state: HeaderState::Write }
    }

    fn wrote_header(&self) -> bool {
        use self::HeaderState::*;
        match self.state {
            Write | ErrorIfWrite(_) => false,
            EncounteredStructField | InStructField => true,
        }
    }

    fn handle_scalar<T: fmt::Display>(
        &mut self,
        name: T,
    ) -> Result<(), Error> {
        use self::HeaderState::*;

        match self.state {
            Write => {
                self.state = ErrorIfWrite(error_scalar_outside_struct(name));
                Ok(())
            }
            ErrorIfWrite(_) | InStructField => Ok(()),
            EncounteredStructField => Err(error_scalar_outside_struct(name)),
        }
    }

    fn handle_container<T: fmt::Display>(
        &mut self,
        name: T,
    ) -> Result<&mut Self, Error> {
        if let HeaderState::InStructField = self.state {
            Err(error_container_inside_struct(name))
        } else {
            Ok(self)
        }
    }
}

impl<'a, 'w, W: io::Write> Serializer for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = Self;
    type SerializeTuple = Self;
    type SerializeTupleStruct = Self;
    type SerializeTupleVariant = Self;
    type SerializeMap = Self;
    type SerializeStruct = Self;
    type SerializeStructVariant = Self;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(v)
    }

    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(value)
    }

    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar("&[u8]")
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar("None")
    }

    fn serialize_some<T: ?Sized + Serialize>(
        self,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar("Some(_)")
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar("()")
    }

    fn serialize_unit_struct(
        self,
        name: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(name)
    }

    fn serialize_unit_variant(
        self,
        name: &'static str,
        _variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(format!("{}::{}", name, variant))
    }

    fn serialize_newtype_struct<T: ?Sized + Serialize>(
        self,
        name: &'static str,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(format!("{}(_)", name))
    }

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        self.handle_scalar(format!("{}::{}(_)", name, variant))
    }

    fn serialize_seq(
        self,
        _len: Option<usize>,
    ) -> Result<Self::SerializeSeq, Self::Error> {
        self.handle_container("sequence")
    }

    fn serialize_tuple(
        self,
        _len: usize,
    ) -> Result<Self::SerializeTuple, Self::Error> {
        self.handle_container("tuple")
    }

    fn serialize_tuple_struct(
        self,
        name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        self.handle_container(name)
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(Error::custom("serializing enum tuple variants is not supported"))
    }

    fn serialize_map(
        self,
        _len: Option<usize>,
    ) -> Result<Self::SerializeMap, Self::Error> {
        // The right behavior for serializing maps isn't clear.
        Err(Error::custom(
            "serializing maps is not supported, \
             if you have a use case, please file an issue at \
             https://github.com/BurntSushi/rust-csv",
        ))
    }

    fn serialize_struct(
        self,
        name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        self.handle_container(name)
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(Error::custom("serializing enum struct variants is not supported"))
    }
}

impl<'a, 'w, W: io::Write> SerializeSeq for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTuple for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTupleStruct for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        value: &T,
    ) -> Result<(), Self::Error> {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeTupleVariant for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl<'a, 'w, W: io::Write> SerializeMap for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized + Serialize>(
        &mut self,
        _key: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn serialize_value<T: ?Sized + Serialize>(
        &mut self,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl<'a, 'w, W: io::Write> SerializeStruct for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        // Grab old state and update state to `EncounteredStructField`.
        let old_state =
            mem::replace(&mut self.state, HeaderState::EncounteredStructField);
        if let HeaderState::ErrorIfWrite(err) = old_state {
            return Err(err);
        }
        self.wtr.write_field(key)?;

        // Check that there aren't any containers in the value.
        self.state = HeaderState::InStructField;
        value.serialize(&mut **self)?;
        self.state = HeaderState::EncounteredStructField;

        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a, 'w, W: io::Write> SerializeStructVariant for &'a mut SeHeader<'w, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        _key: &'static str,
        _value: &T,
    ) -> Result<(), Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

#[cfg(test)]
mod tests {
    use {bstr::ByteSlice, serde::Serialize};

    use crate::{
        error::{Error, ErrorKind},
        writer::Writer,
    };

    use super::{SeHeader, SeRecord};

    fn serialize<S: Serialize>(s: S) -> String {
        let mut wtr = Writer::from_writer(vec![]);
        s.serialize(&mut SeRecord { wtr: &mut wtr }).unwrap();
        wtr.write_record(None::<&[u8]>).unwrap();
        String::from_utf8(wtr.into_inner().unwrap()).unwrap()
    }

    /// Serialize using `SeHeader`. Returns whether a header was written and
    /// the output of the writer.
    fn serialize_header<S: Serialize>(s: S) -> (bool, String) {
        let mut wtr = Writer::from_writer(vec![]);
        let wrote = {
            let mut ser = SeHeader::new(&mut wtr);
            s.serialize(&mut ser).unwrap();
            ser.wrote_header()
        };
        (wrote, String::from_utf8(wtr.into_inner().unwrap()).unwrap())
    }

    fn serialize_err<S: Serialize>(s: S) -> Error {
        let mut wtr = Writer::from_writer(vec![]);
        s.serialize(&mut SeRecord { wtr: &mut wtr }).unwrap_err()
    }

    fn serialize_header_err<S: Serialize>(s: S) -> Error {
        let mut wtr = Writer::from_writer(vec![]);
        s.serialize(&mut SeHeader::new(&mut wtr)).unwrap_err()
    }

    #[test]
    fn bool() {
        let got = serialize(true);
        assert_eq!(got, "true\n");
        let (wrote, got) = serialize_header(true);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn integer() {
        let got = serialize(12345);
        assert_eq!(got, "12345\n");
        let (wrote, got) = serialize_header(12345);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn integer_u128() {
        let got = serialize(i128::MAX as u128 + 1);
        assert_eq!(got, "170141183460469231731687303715884105728\n");
        let (wrote, got) = serialize_header(12345);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn integer_i128() {
        let got = serialize(i128::MAX);
        assert_eq!(got, "170141183460469231731687303715884105727\n");
        let (wrote, got) = serialize_header(12345);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn float() {
        let got = serialize(1.23);
        assert_eq!(got, "1.23\n");
        let (wrote, got) = serialize_header(1.23);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn float_nan() {
        let got = serialize(f64::NAN);
        assert_eq!(got, "NaN\n");
        let (wrote, got) = serialize_header(f64::NAN);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn char() {
        let got = serialize('☃');
        assert_eq!(got, "☃\n");
        let (wrote, got) = serialize_header('☃');
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn str() {
        let got = serialize("how\nare\n\"you\"?");
        assert_eq!(got, "\"how\nare\n\"\"you\"\"?\"\n");
        let (wrote, got) = serialize_header("how\nare\n\"you\"?");
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn bytes() {
        let got = serialize(b"how\nare\n\"you\"?".as_bstr());
        assert_eq!(got, "\"how\nare\n\"\"you\"\"?\"\n");
        let (wrote, got) = serialize_header(&b"how\nare\n\"you\"?"[..]);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn option() {
        let got = serialize(None::<()>);
        assert_eq!(got, "\"\"\n");
        let (wrote, got) = serialize_header(None::<()>);
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize(Some(5));
        assert_eq!(got, "5\n");
        let (wrote, got) = serialize_header(Some(5));
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn unit() {
        let got = serialize(());
        assert_eq!(got, "\"\"\n");
        let (wrote, got) = serialize_header(());
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize((5, ()));
        assert_eq!(got, "5,\n");
        let (wrote, got) = serialize_header(());
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn struct_unit() {
        #[derive(Serialize)]
        struct Foo;

        let got = serialize(Foo);
        assert_eq!(got, "Foo\n");
        let (wrote, got) = serialize_header(Foo);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn struct_newtype() {
        #[derive(Serialize)]
        struct Foo(f64);

        let got = serialize(Foo(1.5));
        assert_eq!(got, "1.5\n");
        let (wrote, got) = serialize_header(Foo(1.5));
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn enum_units() {
        #[derive(Serialize)]
        enum Wat {
            Foo,
            Bar,
            Baz,
        }

        let got = serialize(Wat::Foo);
        assert_eq!(got, "Foo\n");
        let (wrote, got) = serialize_header(Wat::Foo);
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize(Wat::Bar);
        assert_eq!(got, "Bar\n");
        let (wrote, got) = serialize_header(Wat::Bar);
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize(Wat::Baz);
        assert_eq!(got, "Baz\n");
        let (wrote, got) = serialize_header(Wat::Baz);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn enum_newtypes() {
        #[derive(Serialize)]
        enum Wat {
            Foo(i32),
            Bar(f32),
            Baz(bool),
        }

        let got = serialize(Wat::Foo(5));
        assert_eq!(got, "5\n");
        let (wrote, got) = serialize_header(Wat::Foo(5));
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize(Wat::Bar(1.5));
        assert_eq!(got, "1.5\n");
        let (wrote, got) = serialize_header(Wat::Bar(1.5));
        assert!(!wrote);
        assert_eq!(got, "");

        let got = serialize(Wat::Baz(true));
        assert_eq!(got, "true\n");
        let (wrote, got) = serialize_header(Wat::Baz(true));
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn seq() {
        let got = serialize(vec![1, 2, 3]);
        assert_eq!(got, "1,2,3\n");
        let (wrote, got) = serialize_header(vec![1, 2, 3]);
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn tuple() {
        let row = (true, 1.5, "hi");
        let got = serialize(row);
        assert_eq!(got, "true,1.5,hi\n");
        let (wrote, got) = serialize_header(row);
        assert!(!wrote);
        assert_eq!(got, "");

        let row = (true, 1.5, vec![1, 2, 3]);
        let got = serialize(row.clone());
        assert_eq!(got, "true,1.5,1,2,3\n");
        let (wrote, got) = serialize_header(row.clone());
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn tuple_struct() {
        #[derive(Clone, Serialize)]
        struct Foo(bool, i32, String);

        let row = Foo(false, 42, "hi".to_string());
        let got = serialize(row.clone());
        assert_eq!(got, "false,42,hi\n");
        let (wrote, got) = serialize_header(row.clone());
        assert!(!wrote);
        assert_eq!(got, "");
    }

    #[test]
    fn tuple_variant() {
        #[derive(Clone, Serialize)]
        enum Foo {
            X(bool, i32, String),
        }

        let row = Foo::X(false, 42, "hi".to_string());
        let err = serialize_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn enum_struct_variant() {
        #[derive(Clone, Serialize)]
        enum Foo {
            X { a: bool, b: i32, c: String },
        }

        let row = Foo::X { a: false, b: 1, c: "hi".into() };
        let err = serialize_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn struct_no_headers() {
        #[derive(Serialize)]
        struct Foo {
            x: bool,
            y: i32,
            z: String,
        }

        let got = serialize(Foo { x: true, y: 5, z: "hi".into() });
        assert_eq!(got, "true,5,hi\n");
    }

    #[test]
    fn struct_no_headers_128() {
        #[derive(Serialize)]
        struct Foo {
            x: i128,
            y: u128,
        }

        let got = serialize(Foo { x: i128::MAX, y: u128::MAX });
        assert_eq!(
            got,
            "170141183460469231731687303715884105727,\
                 340282366920938463463374607431768211455\n"
        );
    }

    #[test]
    fn struct_headers() {
        #[derive(Clone, Serialize)]
        struct Foo {
            x: bool,
            y: i32,
            z: String,
        }

        let row = Foo { x: true, y: 5, z: "hi".into() };
        let (wrote, got) = serialize_header(row.clone());
        assert!(wrote);
        assert_eq!(got, "x,y,z");
        let got = serialize(row.clone());
        assert_eq!(got, "true,5,hi\n");
    }

    #[test]
    fn struct_headers_nested() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            nest: Nested,
        }
        #[derive(Clone, Serialize)]
        struct Nested {
            label2: String,
            value: i32,
        }

        let row = Foo {
            label: "foo".into(),
            nest: Nested { label2: "bar".into(), value: 5 },
        };

        let got = serialize(row.clone());
        assert_eq!(got, "foo,bar,5\n");

        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn struct_headers_nested_seq() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            values: Vec<i32>,
        }
        let row = Foo { label: "foo".into(), values: vec![1, 2, 3] };

        let got = serialize(row.clone());
        assert_eq!(got, "foo,1,2,3\n");

        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn struct_headers_inside_tuple() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            num: f64,
        }
        #[derive(Clone, Serialize)]
        struct Bar {
            label2: bool,
            value: i32,
            empty: (),
        }
        let row = (
            Foo { label: "hi".to_string(), num: 5.0 },
            Bar { label2: true, value: 3, empty: () },
            Foo { label: "baz".to_string(), num: 2.3 },
        );

        let got = serialize(row.clone());
        assert_eq!(got, "hi,5.0,true,3,,baz,2.3\n");

        let (wrote, got) = serialize_header(row.clone());
        assert!(wrote);
        assert_eq!(got, "label,num,label2,value,empty,label,num");
    }

    #[test]
    fn struct_headers_inside_tuple_scalar_before() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            num: f64,
        }
        let row = (3.14, Foo { label: "hi".to_string(), num: 5.0 });

        let got = serialize(row.clone());
        assert_eq!(got, "3.14,hi,5.0\n");

        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn struct_headers_inside_tuple_scalar_after() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            num: f64,
        }
        let row = (Foo { label: "hi".to_string(), num: 5.0 }, 3.14);

        let got = serialize(row.clone());
        assert_eq!(got, "hi,5.0,3.14\n");

        let err = serialize_header_err(row.clone());
        match *err.kind() {
            ErrorKind::Serialize(_) => {}
            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
        }
    }

    #[test]
    fn struct_headers_inside_seq() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            num: f64,
        }
        let row = vec![
            Foo { label: "hi".to_string(), num: 5.0 },
            Foo { label: "baz".to_string(), num: 2.3 },
        ];

        let got = serialize(row.clone());
        assert_eq!(got, "hi,5.0,baz,2.3\n");

        let (wrote, got) = serialize_header(row.clone());
        assert!(wrote);
        assert_eq!(got, "label,num,label,num");
    }

    #[test]
    fn struct_headers_inside_nested_tuple_seq() {
        #[derive(Clone, Serialize)]
        struct Foo {
            label: String,
            num: f64,
        }
        #[derive(Clone, Serialize)]
        struct Bar {
            label2: Baz,
            value: i32,
            empty: (),
        }
        #[derive(Clone, Serialize)]
        struct Baz(bool);
        let row = (
            (
                Foo { label: "hi".to_string(), num: 5.0 },
                Bar { label2: Baz(true), value: 3, empty: () },
            ),
            vec![(Foo { label: "baz".to_string(), num: 2.3 },)],
        );

        let got = serialize(row.clone());
        assert_eq!(got, "hi,5.0,true,3,,baz,2.3\n");

        let (wrote, got) = serialize_header(row.clone());
        assert!(wrote);
        assert_eq!(got, "label,num,label2,value,empty,label,num");
    }
}

Coverage Report

Created: 2026-01-25 06:45