Skip to main content

uuid/external/
serde_support.rs

1// Copyright 2013-2014 The Rust Project Developers.
2// Copyright 2018 The Uuid Project Developers.
3//
4// See the COPYRIGHT file at the top-level directory of this distribution.
5//
6// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
7// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
8// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
9// option. This file may not be copied, modified, or distributed
10// except according to those terms.
11
12use core::marker::PhantomData;
13
14use crate::{
15    error::*,
16    fmt::{Braced, Hyphenated, Simple, Urn},
17    non_nil::NonNilUuid,
18    std::fmt,
19    Bytes, Uuid,
20};
21use serde_core::{
22    de::{self, Error as _},
23    Deserialize, Deserializer, Serialize, Serializer,
24};
25
26impl Serialize for Uuid {
27    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
28        if serializer.is_human_readable() {
29            serializer.serialize_str(self.hyphenated().encode_lower(&mut Uuid::encode_buffer()))
30        } else {
31            serializer.serialize_bytes(self.as_bytes())
32        }
33    }
34}
35
36impl Serialize for NonNilUuid {
37    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38    where
39        S: serde_core::Serializer,
40    {
41        Uuid::from(*self).serialize(serializer)
42    }
43}
44
45impl Serialize for Hyphenated {
46    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
47        serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
48    }
49}
50
51impl Serialize for Simple {
52    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
53        serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
54    }
55}
56
57impl Serialize for Urn {
58    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
59        serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
60    }
61}
62
63impl Serialize for Braced {
64    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
65        serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer()))
66    }
67}
68
69impl UuidDeserialize for Uuid {
70    fn expecting() -> &'static str {
71        "a formatted UUID string"
72    }
73
74    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
75        formatted.parse().map_err(de_error)
76    }
77
78    fn from_slice<E: de::Error>(bytes: &[u8]) -> Result<Self, E> {
79        Uuid::from_slice(bytes).map_err(de_error)
80    }
81
82    fn from_bytes<E: de::Error>(bytes: Bytes) -> Result<Self, E> {
83        Ok(Uuid::from_bytes(bytes))
84    }
85}
86
87impl<'de> Deserialize<'de> for Uuid {
88    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
89        if deserializer.is_human_readable() {
90            deserializer.deserialize_str(UuidReadableVisitor {
91                _marker: PhantomData::<Uuid>,
92            })
93        } else {
94            deserializer.deserialize_bytes(UuidBytesVisitor {
95                _marker: PhantomData::<Uuid>,
96            })
97        }
98    }
99}
100
101impl UuidDeserialize for Braced {
102    fn expecting() -> &'static str {
103        "a UUID string in the braced format"
104    }
105
106    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
107        formatted.parse().map_err(de_error)
108    }
109}
110
111impl<'de> Deserialize<'de> for Braced {
112    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
113        deserializer.deserialize_str(UuidReadableVisitor {
114            _marker: PhantomData::<Braced>,
115        })
116    }
117}
118
119impl UuidDeserialize for Hyphenated {
120    fn expecting() -> &'static str {
121        "a UUID string in the hyphenated format"
122    }
123
124    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
125        formatted.parse().map_err(de_error)
126    }
127}
128
129impl<'de> Deserialize<'de> for Hyphenated {
130    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
131        deserializer.deserialize_str(UuidReadableVisitor {
132            _marker: PhantomData::<Hyphenated>,
133        })
134    }
135}
136
137impl UuidDeserialize for Simple {
138    fn expecting() -> &'static str {
139        "a UUID string in the simple format"
140    }
141
142    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
143        formatted.parse().map_err(de_error)
144    }
145}
146
147impl<'de> Deserialize<'de> for Simple {
148    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
149        deserializer.deserialize_str(UuidReadableVisitor {
150            _marker: PhantomData::<Simple>,
151        })
152    }
153}
154
155impl UuidDeserialize for Urn {
156    fn expecting() -> &'static str {
157        "a UUID string in the URN format"
158    }
159
160    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E> {
161        formatted.parse().map_err(de_error)
162    }
163}
164
165impl<'de> Deserialize<'de> for Urn {
166    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
167        deserializer.deserialize_str(UuidReadableVisitor {
168            _marker: PhantomData::<Urn>,
169        })
170    }
171}
172
173impl<'de> Deserialize<'de> for NonNilUuid {
174    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
175    where
176        D: Deserializer<'de>,
177    {
178        let uuid = Uuid::deserialize(deserializer)?;
179
180        NonNilUuid::try_from(uuid).map_err(|_| {
181            de::Error::invalid_value(de::Unexpected::Other("nil UUID"), &"a non-nil UUID")
182        })
183    }
184}
185
186struct UuidReadableVisitor<T> {
187    _marker: PhantomData<T>,
188}
189
190impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidReadableVisitor<T> {
191    type Value = T;
192
193    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
194        formatter.write_str(T::expecting())
195    }
196
197    fn visit_str<E: de::Error>(self, value: &str) -> Result<T, E> {
198        T::from_str(value)
199    }
200
201    fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
202        T::from_slice(value)
203    }
204
205    fn visit_seq<A>(self, seq: A) -> Result<T, A::Error>
206    where
207        A: de::SeqAccess<'vi>,
208    {
209        UuidBytesVisitor {
210            _marker: PhantomData,
211        }
212        .visit_seq(seq)
213    }
214}
215
216struct UuidBytesVisitor<T> {
217    _marker: PhantomData<T>,
218}
219
220impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidBytesVisitor<T> {
221    type Value = T;
222
223    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
224        write!(formatter, "a 16 byte array")
225    }
226
227    fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
228        T::from_slice(value)
229    }
230
231    fn visit_seq<A>(self, mut seq: A) -> Result<T, A::Error>
232    where
233        A: de::SeqAccess<'vi>,
234    {
235        let mut bytes = [0; 16];
236
237        let mut i = 0;
238        for byte in bytes.iter_mut() {
239            let Some(e) = seq.next_element()? else {
240                break;
241            };
242
243            *byte = e;
244
245            i += 1;
246        }
247
248        while seq.next_element::<de::IgnoredAny>()?.is_some() {
249            i += 1;
250        }
251
252        if i != 16 {
253            return Err(A::Error::invalid_length(i, &self));
254        }
255
256        T::from_bytes(bytes)
257    }
258}
259
260fn de_error<E: de::Error>(e: Error) -> E {
261    E::custom(format_args!("UUID parsing failed: {}", e))
262}
263
264trait UuidDeserialize {
265    fn expecting() -> &'static str;
266
267    fn from_str<E: de::Error>(formatted: &str) -> Result<Self, E>
268    where
269        Self: Sized,
270    {
271        Err(E::invalid_type(
272            de::Unexpected::Str(formatted),
273            &Self::expecting(),
274        ))
275    }
276
277    fn from_slice<E: de::Error>(bytes: &[u8]) -> Result<Self, E>
278    where
279        Self: Sized,
280    {
281        Err(E::invalid_type(
282            de::Unexpected::Bytes(bytes),
283            &Self::expecting(),
284        ))
285    }
286
287    fn from_bytes<E: de::Error>(bytes: Bytes) -> Result<Self, E>
288    where
289        Self: Sized,
290    {
291        Self::from_slice(bytes.as_ref())
292    }
293}
294
295pub mod compact {
296    //! Serialize a [`Uuid`] as a `[u8; 16]`.
297    //!
298    //! [`Uuid`]: ../../struct.Uuid.html
299
300    /// Serialize from a [`Uuid`] as a `[u8; 16]`
301    ///
302    /// [`Uuid`]: ../../struct.Uuid.html
303    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
304    where
305        S: serde_core::Serializer,
306    {
307        serde_core::Serialize::serialize(u.as_bytes(), serializer)
308    }
309
310    /// Deserialize a `[u8; 16]` as a [`Uuid`]
311    ///
312    /// [`Uuid`]: ../../struct.Uuid.html
313    pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
314    where
315        D: serde_core::Deserializer<'de>,
316    {
317        let bytes: [u8; 16] = serde_core::Deserialize::deserialize(deserializer)?;
318
319        Ok(crate::Uuid::from_bytes(bytes))
320    }
321
322    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) as an optional `[u8; 16]`.
323    pub mod option {
324        /// Serialize an optional [`Uuid`](crate::Uuid) as an optional `[u8; 16]`.
325        pub fn serialize<S>(u: &Option<crate::Uuid>, serializer: S) -> Result<S::Ok, S::Error>
326        where
327            S: serde_core::Serializer,
328        {
329            match u {
330                Some(u) => serializer.serialize_some(u.as_bytes()),
331                None => serializer.serialize_none(),
332            }
333        }
334
335        /// Deserialize an optional `[u8; 16]` as an optional [`Uuid`](crate::Uuid).
336        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<crate::Uuid>, D::Error>
337        where
338            D: serde_core::Deserializer<'de>,
339        {
340            <Option<[u8; 16]> as serde_core::Deserialize>::deserialize(deserializer)
341                .map(|bytes| bytes.map(crate::Uuid::from_bytes))
342        }
343    }
344
345    #[cfg(test)]
346    mod tests {
347        use serde_derive::*;
348        use serde_test::{Configure, Token};
349
350        use crate::Uuid;
351
352        const BYTES: [u8; 16] = [
353            0xf9, 0x16, 0x8c, 0x5e, 0xce, 0xb2, 0x4f, 0xaa, 0xb6, 0xbf, 0x32, 0x9b, 0xf3, 0x9f,
354            0xa1, 0xe4,
355        ];
356
357        #[test]
358        fn test_compact_option() {
359            #[derive(Debug, PartialEq, Serialize, Deserialize)]
360            struct Field {
361                #[serde(with = "crate::serde::compact::option")]
362                id: Option<Uuid>,
363            }
364
365            let present = Field {
366                id: Some(Uuid::from_bytes(BYTES)),
367            };
368            let absent = Field { id: None };
369            let tokens = [
370                Token::Struct {
371                    name: "Field",
372                    len: 1,
373                },
374                Token::Str("id"),
375                Token::Some,
376                Token::Tuple { len: 16 },
377                Token::U8(BYTES[0]),
378                Token::U8(BYTES[1]),
379                Token::U8(BYTES[2]),
380                Token::U8(BYTES[3]),
381                Token::U8(BYTES[4]),
382                Token::U8(BYTES[5]),
383                Token::U8(BYTES[6]),
384                Token::U8(BYTES[7]),
385                Token::U8(BYTES[8]),
386                Token::U8(BYTES[9]),
387                Token::U8(BYTES[10]),
388                Token::U8(BYTES[11]),
389                Token::U8(BYTES[12]),
390                Token::U8(BYTES[13]),
391                Token::U8(BYTES[14]),
392                Token::U8(BYTES[15]),
393                Token::TupleEnd,
394                Token::StructEnd,
395            ];
396            serde_test::assert_tokens(&present, &tokens);
397            let none_tokens = [
398                Token::Struct {
399                    name: "Field",
400                    len: 1,
401                },
402                Token::Str("id"),
403                Token::None,
404                Token::StructEnd,
405            ];
406            serde_test::assert_tokens(&absent, &none_tokens);
407        }
408
409        #[test]
410        fn test_serialize_compact() {
411            #[derive(Serialize, Debug, Deserialize, PartialEq)]
412            struct UuidContainer {
413                #[serde(with = "crate::serde::compact")]
414                u: crate::Uuid,
415            }
416
417            let uuid_bytes = b"F9168C5E-CEB2-4F";
418            let container = UuidContainer {
419                u: crate::Uuid::from_slice(uuid_bytes).unwrap(),
420            };
421
422            // more complex because of the struct wrapping the actual UUID
423            // serialization
424            serde_test::assert_tokens(
425                &container.compact(),
426                &[
427                    Token::Struct {
428                        name: "UuidContainer",
429                        len: 1,
430                    },
431                    Token::Str("u"),
432                    Token::Tuple { len: 16 },
433                    Token::U8(uuid_bytes[0]),
434                    Token::U8(uuid_bytes[1]),
435                    Token::U8(uuid_bytes[2]),
436                    Token::U8(uuid_bytes[3]),
437                    Token::U8(uuid_bytes[4]),
438                    Token::U8(uuid_bytes[5]),
439                    Token::U8(uuid_bytes[6]),
440                    Token::U8(uuid_bytes[7]),
441                    Token::U8(uuid_bytes[8]),
442                    Token::U8(uuid_bytes[9]),
443                    Token::U8(uuid_bytes[10]),
444                    Token::U8(uuid_bytes[11]),
445                    Token::U8(uuid_bytes[12]),
446                    Token::U8(uuid_bytes[13]),
447                    Token::U8(uuid_bytes[14]),
448                    Token::U8(uuid_bytes[15]),
449                    Token::TupleEnd,
450                    Token::StructEnd,
451                ],
452            )
453        }
454    }
455}
456
457/// Serialize a [`Uuid`] as a byte string.
458///
459/// Unlike [`compact`](crate::serde::compact), which serializes a [`Uuid`] as a
460/// `[u8; 16]` array, this module uses the serializer's dedicated byte string
461/// support through [`serialize_bytes`]. Formats that distinguish byte strings
462/// from sequences, such as CBOR or MessagePack, can then encode the [`Uuid`] as
463/// a single 16 byte string instead of a sequence of 16 individually encoded
464/// integers.
465///
466/// [`Uuid`]: ../../struct.Uuid.html
467/// [`serialize_bytes`]: serde_core::Serializer::serialize_bytes
468///
469/// ## Examples
470///
471/// ```
472/// # use uuid::Uuid;
473/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
474/// struct Container {
475///     #[serde(with = "uuid::serde::bytes")]
476///     id: Uuid,
477/// }
478/// ```
479pub mod bytes {
480    use super::*;
481
482    struct ByteUuid(crate::Uuid);
483
484    impl serde_core::Serialize for ByteUuid {
485        fn serialize<S: serde_core::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
486            serializer.serialize_bytes(self.0.as_bytes())
487        }
488    }
489
490    impl<'de> serde_core::Deserialize<'de> for ByteUuid {
491        fn deserialize<D: serde_core::Deserializer<'de>>(
492            deserializer: D,
493        ) -> Result<Self, D::Error> {
494            deserializer
495                .deserialize_bytes(UuidBytesVisitor {
496                    _marker: PhantomData::<crate::Uuid>,
497                })
498                .map(Self)
499        }
500    }
501
502    /// Serialize from a [`Uuid`] as a byte string.
503    ///
504    /// [`Uuid`]: ../../struct.Uuid.html
505    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
506    where
507        S: serde_core::Serializer,
508    {
509        ByteUuid(*u).serialize(serializer)
510    }
511
512    /// Deserialize a byte string as a [`Uuid`].
513    ///
514    /// [`Uuid`]: ../../struct.Uuid.html
515    pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
516    where
517        D: serde_core::Deserializer<'de>,
518    {
519        ByteUuid::deserialize(deserializer).map(|u| u.0)
520    }
521
522    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) as an optional byte string.
523    pub mod option {
524        use super::*;
525
526        /// Serialize an optional [`Uuid`](crate::Uuid) as an optional byte string.
527        pub fn serialize<S>(u: &Option<crate::Uuid>, serializer: S) -> Result<S::Ok, S::Error>
528        where
529            S: serde_core::Serializer,
530        {
531            match u {
532                Some(u) => serializer.serialize_some(&ByteUuid(*u)),
533                None => serializer.serialize_none(),
534            }
535        }
536
537        /// Deserialize an optional byte string as an optional [`Uuid`](crate::Uuid).
538        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<crate::Uuid>, D::Error>
539        where
540            D: serde_core::Deserializer<'de>,
541        {
542            Option::<ByteUuid>::deserialize(deserializer).map(|u| u.map(|u| u.0))
543        }
544    }
545
546    #[cfg(test)]
547    mod tests {
548        use serde_derive::*;
549
550        use crate::Uuid;
551        use serde_test::Token;
552
553        const BYTES: [u8; 16] = [
554            0xf9, 0x16, 0x8c, 0x5e, 0xce, 0xb2, 0x4f, 0xaa, 0xb6, 0xbf, 0x32, 0x9b, 0xf3, 0x9f,
555            0xa1, 0xe4,
556        ];
557
558        #[test]
559        fn test_bytes_option() {
560            #[derive(Debug, PartialEq, Serialize, Deserialize)]
561            struct Field {
562                #[serde(with = "crate::serde::bytes::option")]
563                id: Option<Uuid>,
564            }
565
566            let present = Field {
567                id: Some(Uuid::from_bytes(BYTES)),
568            };
569            let absent = Field { id: None };
570            let present_tokens = [
571                Token::Struct {
572                    name: "Field",
573                    len: 1,
574                },
575                Token::Str("id"),
576                Token::Some,
577                Token::Bytes(&BYTES),
578                Token::StructEnd,
579            ];
580            let none_tokens = [
581                Token::Struct {
582                    name: "Field",
583                    len: 1,
584                },
585                Token::Str("id"),
586                Token::None,
587                Token::StructEnd,
588            ];
589            serde_test::assert_tokens(&present, &present_tokens);
590            serde_test::assert_tokens(&absent, &none_tokens);
591        }
592
593        #[test]
594        fn test_serialize_bytes() {
595            #[derive(Serialize, Debug, Deserialize, PartialEq)]
596            struct UuidContainer {
597                #[serde(with = "crate::serde::bytes")]
598                u: crate::Uuid,
599            }
600
601            let uuid_bytes = b"F9168C5E-CEB2-4F";
602            let container = UuidContainer {
603                u: crate::Uuid::from_slice(uuid_bytes).unwrap(),
604            };
605
606            serde_test::assert_tokens(
607                &container,
608                &[
609                    serde_test::Token::Struct {
610                        name: "UuidContainer",
611                        len: 1,
612                    },
613                    serde_test::Token::Str("u"),
614                    serde_test::Token::Bytes(uuid_bytes),
615                    serde_test::Token::StructEnd,
616                ],
617            )
618        }
619
620        #[test]
621        fn test_de_bytes_from_seq() {
622            #[derive(Serialize, Debug, Deserialize, PartialEq)]
623            struct UuidContainer {
624                #[serde(with = "crate::serde::bytes")]
625                u: crate::Uuid,
626            }
627
628            let container = UuidContainer {
629                u: Uuid::from_bytes(BYTES),
630            };
631
632            // Formats without a byte string type, like JSON, serialize bytes as a sequence
633            let json = serde_json::to_string(&container).unwrap();
634            assert_eq!(container, serde_json::from_str(&json).unwrap());
635
636            serde_test::assert_de_tokens_error::<UuidContainer>(
637                &[
638                    Token::Struct {
639                        name: "UuidContainer",
640                        len: 1,
641                    },
642                    Token::Str("u"),
643                    Token::Seq { len: Some(1) },
644                    Token::U8(BYTES[0]),
645                    Token::SeqEnd,
646                ],
647                "invalid length 1, expected a 16 byte array",
648            );
649        }
650    }
651}
652
653/// Serialize a [`Uuid`] as [`uuid::fmt::Simple`](crate::fmt::Simple).
654///
655/// [`Uuid`]: ../../struct.Uuid.html
656///
657/// ## Examples
658///
659/// Serialize and deserialize using the simple format, failing to deserialize
660/// any other format:
661///
662/// ```
663/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
664/// struct StructA {
665///     #[serde(with = "uuid::serde::simple")]
666///     id: uuid::Uuid,
667/// }
668/// ```
669///
670/// Serialize using the simple format, but deserialize any format:
671///
672/// ```
673/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
674/// struct StructB {
675///     #[serde(serialize_with = "uuid::serde::simple::serialize")]
676///     id: uuid::Uuid,
677/// }
678/// ```
679pub mod simple {
680    use super::*;
681
682    /// Serialize a [`Uuid`] as a simple string.
683    ///
684    /// [`Uuid`]: ../../struct.Uuid.html
685    ///
686    /// # Examples
687    ///
688    /// ```
689    /// #[derive(serde_derive::Serialize)]
690    /// struct Struct {
691    ///     #[serde(serialize_with = "uuid::serde::simple::serialize")]
692    ///     id: uuid::Uuid,
693    /// }
694    ///
695    /// ```
696    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
697    where
698        S: serde_core::Serializer,
699    {
700        serde_core::Serialize::serialize(u.as_simple(), serializer)
701    }
702
703    /// Deserialize a simple-formatted string as a [`Uuid`].
704    ///
705    /// [`Uuid`]: ../../struct.Uuid.html
706    pub fn deserialize<'de, D>(deserializer: D) -> Result<Uuid, D::Error>
707    where
708        D: serde_core::Deserializer<'de>,
709    {
710        Ok(Simple::deserialize(deserializer)?.into())
711    }
712
713    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) in the simple format.
714    pub mod option {
715        use super::*;
716
717        /// Serialize an optional [`Uuid`](crate::Uuid) in the simple format.
718        pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
719        where
720            S: serde_core::Serializer,
721        {
722            match u {
723                Some(u) => serializer.serialize_some(u.as_simple()),
724                None => serializer.serialize_none(),
725            }
726        }
727
728        /// Deserialize an optional simple string as an optional [`Uuid`](crate::Uuid).
729        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
730        where
731            D: serde_core::Deserializer<'de>,
732        {
733            Option::<Simple>::deserialize(deserializer).map(|u| u.map(Into::into))
734        }
735    }
736
737    #[cfg(test)]
738    mod tests {
739        use serde::de::{self, Error};
740        use serde_test::{Readable, Token};
741
742        use super::*;
743
744        const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
745        const SIMPLE_UUID_STR: &str = "f9168c5eceb24faab6bf329bf39fa1e4";
746
747        #[test]
748        fn test_simple_option() {
749            #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
750            struct Field {
751                #[serde(with = "crate::serde::simple::option")]
752                id: Option<Uuid>,
753            }
754
755            let present = Field {
756                id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
757            };
758            let absent = Field { id: None };
759            let present_tokens = [
760                Token::Struct {
761                    name: "Field",
762                    len: 1,
763                },
764                Token::Str("id"),
765                Token::Some,
766                Token::Str(SIMPLE_UUID_STR),
767                Token::StructEnd,
768            ];
769            let absent_tokens = [
770                Token::Struct {
771                    name: "Field",
772                    len: 1,
773                },
774                Token::Str("id"),
775                Token::None,
776                Token::StructEnd,
777            ];
778
779            serde_test::assert_tokens(&present, &present_tokens);
780            serde_test::assert_tokens(&absent, &absent_tokens);
781        }
782
783        #[test]
784        fn test_serialize_as_simple() {
785            #[derive(serde_derive::Serialize)]
786            struct Struct(#[serde(with = "super")] crate::Uuid);
787
788            let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
789            serde_test::assert_ser_tokens(
790                &u,
791                &[
792                    Token::NewtypeStruct { name: "Struct" },
793                    Token::Str(SIMPLE_UUID_STR),
794                ],
795            );
796        }
797
798        #[test]
799        fn test_de_from_simple() {
800            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
801            struct Struct(#[serde(with = "super")] crate::Uuid);
802            let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
803            serde_test::assert_de_tokens::<Struct>(
804                &s,
805                &[
806                    Token::TupleStruct {
807                        name: "Struct",
808                        len: 1,
809                    },
810                    Token::BorrowedStr(SIMPLE_UUID_STR),
811                    Token::TupleStructEnd,
812                ],
813            );
814        }
815
816        #[test]
817        fn test_de_reject_hyphenated() {
818            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
819            struct Struct(#[serde(with = "super")] crate::Uuid);
820            serde_test::assert_de_tokens_error::<Readable<Struct>>(
821                &[
822                    Token::TupleStruct {
823                        name: "Struct",
824                        len: 1,
825                    },
826                    Token::BorrowedStr(HYPHENATED_UUID_STR),
827                    Token::TupleStructEnd,
828                ],
829                &format!(
830                    "{}",
831                    de::value::Error::custom(
832                        "UUID parsing failed: invalid character: found `-` at 8"
833                    )
834                ),
835            );
836        }
837
838        #[test]
839        fn test_de_reject_seq() {
840            let uuid_bytes = b"F9168C5E-CEB2-4F";
841
842            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
843            struct Struct(#[serde(with = "super")] crate::Uuid);
844            serde_test::assert_de_tokens_error::<Readable<Struct>>(
845                &[
846                    Token::TupleStruct {
847                        name: "Struct",
848                        len: 1,
849                    },
850                    Token::Bytes(uuid_bytes),
851                    Token::TupleStructEnd,
852                ],
853                &format!(
854                    "{}",
855                    de::value::Error::custom(
856                        "invalid type: byte array, expected a UUID string in the simple format"
857                    )
858                ),
859            );
860        }
861    }
862}
863
864/// Serialize a [`Uuid`] as [`uuid::fmt::Braced`](crate::fmt::Braced).
865///
866/// [`Uuid`]: ../../struct.Uuid.html
867///
868/// ## Examples
869///
870/// Serialize and deserialize using the braced format, failing to deserialize
871/// any other format:
872///
873/// ```
874/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
875/// struct StructA {
876///     #[serde(with = "uuid::serde::braced")]
877///     id: uuid::Uuid,
878/// }
879/// ```
880///
881/// Serialize using the braced format, but deserialize any format:
882///
883/// ```
884/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
885/// struct StructB {
886///     #[serde(serialize_with = "uuid::serde::braced::serialize")]
887///     id: uuid::Uuid,
888/// }
889/// ```
890pub mod braced {
891    use super::*;
892
893    /// Serialize a [`Uuid`] as a braced string.
894    ///
895    /// [`Uuid`]: ../../struct.Uuid.html
896    ///
897    /// # Examples
898    ///
899    /// ```
900    /// #[derive(serde_derive::Serialize)]
901    /// struct Struct {
902    ///     #[serde(serialize_with = "uuid::serde::braced::serialize")]
903    ///     id: uuid::Uuid,
904    /// }
905    ///
906    /// ```
907    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
908    where
909        S: serde_core::Serializer,
910    {
911        serde_core::Serialize::serialize(u.as_braced(), serializer)
912    }
913
914    /// Deserialize a braced-formatted string as a [`Uuid`].
915    ///
916    /// [`Uuid`]: ../../struct.Uuid.html
917    pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
918    where
919        D: serde_core::Deserializer<'de>,
920    {
921        Ok(Braced::deserialize(deserializer)?.into())
922    }
923
924    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) in the braced format.
925    pub mod option {
926        use super::*;
927
928        /// Serialize an optional [`Uuid`](crate::Uuid) in the braced format.
929        pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
930        where
931            S: serde_core::Serializer,
932        {
933            match u {
934                Some(u) => serializer.serialize_some(u.as_braced()),
935                None => serializer.serialize_none(),
936            }
937        }
938
939        /// Deserialize an optional braced string as an optional [`Uuid`](crate::Uuid).
940        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
941        where
942            D: serde_core::Deserializer<'de>,
943        {
944            Option::<Braced>::deserialize(deserializer).map(|u| u.map(Into::into))
945        }
946    }
947
948    #[cfg(test)]
949    mod tests {
950
951        use super::*;
952        use serde::de::{self, Error};
953        use serde_test::{Readable, Token};
954
955        const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
956        const BRACED_UUID_STR: &str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
957
958        #[test]
959        fn test_braced_option() {
960            #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
961            struct Field {
962                #[serde(with = "crate::serde::braced::option")]
963                id: Option<Uuid>,
964            }
965
966            let present = Field {
967                id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
968            };
969            let absent = Field { id: None };
970            let present_tokens = [
971                Token::Struct {
972                    name: "Field",
973                    len: 1,
974                },
975                Token::Str("id"),
976                Token::Some,
977                Token::Str(BRACED_UUID_STR),
978                Token::StructEnd,
979            ];
980            let absent_tokens = [
981                Token::Struct {
982                    name: "Field",
983                    len: 1,
984                },
985                Token::Str("id"),
986                Token::None,
987                Token::StructEnd,
988            ];
989
990            serde_test::assert_tokens(&present, &present_tokens);
991            serde_test::assert_tokens(&absent, &absent_tokens);
992        }
993
994        #[test]
995        fn test_serialize_as_braced() {
996            #[derive(serde_derive::Serialize)]
997            struct Struct(#[serde(with = "super")] crate::Uuid);
998
999            let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1000            serde_test::assert_ser_tokens(
1001                &u,
1002                &[
1003                    Token::NewtypeStruct { name: "Struct" },
1004                    Token::Str(BRACED_UUID_STR),
1005                ],
1006            );
1007        }
1008
1009        #[test]
1010        fn test_de_from_braced() {
1011            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1012            struct Struct(#[serde(with = "super")] crate::Uuid);
1013            let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1014            serde_test::assert_de_tokens::<Struct>(
1015                &s,
1016                &[
1017                    Token::TupleStruct {
1018                        name: "Struct",
1019                        len: 1,
1020                    },
1021                    Token::BorrowedStr(BRACED_UUID_STR),
1022                    Token::TupleStructEnd,
1023                ],
1024            );
1025        }
1026
1027        #[test]
1028        fn test_de_reject_hyphenated() {
1029            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1030            struct Struct(#[serde(with = "super")] crate::Uuid);
1031            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1032                &[
1033                    Token::TupleStruct {
1034                        name: "Struct",
1035                        len: 1,
1036                    },
1037                    Token::BorrowedStr(HYPHENATED_UUID_STR),
1038                    Token::TupleStructEnd,
1039                ],
1040                &format!(
1041                    "{}",
1042                    de::value::Error::custom(
1043                        "UUID parsing failed: invalid character: found `f` at 0"
1044                    )
1045                ),
1046            );
1047        }
1048
1049        #[test]
1050        fn test_de_reject_seq() {
1051            let uuid_bytes = b"F9168C5E-CEB2-4F";
1052
1053            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1054            struct Struct(#[serde(with = "super")] crate::Uuid);
1055            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1056                &[
1057                    Token::TupleStruct {
1058                        name: "Struct",
1059                        len: 1,
1060                    },
1061                    Token::Bytes(uuid_bytes),
1062                    Token::TupleStructEnd,
1063                ],
1064                &format!(
1065                    "{}",
1066                    de::value::Error::custom(
1067                        "invalid type: byte array, expected a UUID string in the braced format"
1068                    )
1069                ),
1070            );
1071        }
1072    }
1073}
1074
1075/// Serialize a [`Uuid`] as [`uuid::fmt::Hyphenated`](crate::fmt::Hyphenated).
1076///
1077/// [`Uuid`]: ../../struct.Uuid.html
1078///
1079/// ## Examples
1080///
1081/// Serialize and deserialize using the hyphenated format, failing to deserialize
1082/// any other format:
1083///
1084/// ```
1085/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
1086/// struct StructA {
1087///     #[serde(with = "uuid::serde::hyphenated")]
1088///     id: uuid::Uuid,
1089/// }
1090/// ```
1091///
1092/// Serialize using the hyphenated format, but deserialize any format:
1093///
1094/// ```
1095/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
1096/// struct StructB {
1097///     #[serde(serialize_with = "uuid::serde::hyphenated::serialize")]
1098///     id: uuid::Uuid,
1099/// }
1100/// ```
1101pub mod hyphenated {
1102
1103    use super::*;
1104
1105    /// Serialize a [`Uuid`] as a hyphenated string.
1106    ///
1107    /// [`Uuid`]: ../../struct.Uuid.html
1108    ///
1109    /// # Examples
1110    ///
1111    /// ```
1112    /// #[derive(serde_derive::Serialize)]
1113    /// struct Struct {
1114    ///     #[serde(serialize_with = "uuid::serde::hyphenated::serialize")]
1115    ///     id: uuid::Uuid,
1116    /// }
1117    ///
1118    /// ```
1119    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
1120    where
1121        S: serde_core::Serializer,
1122    {
1123        serde_core::Serialize::serialize(u.as_hyphenated(), serializer)
1124    }
1125
1126    /// Deserialize a hyphenated-formatted string as a [`Uuid`].
1127    ///
1128    /// [`Uuid`]: ../../struct.Uuid.html
1129    pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
1130    where
1131        D: serde_core::Deserializer<'de>,
1132    {
1133        Ok(Hyphenated::deserialize(deserializer)?.into())
1134    }
1135
1136    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) in the hyphenated format.
1137    pub mod option {
1138        use super::*;
1139
1140        /// Serialize an optional [`Uuid`](crate::Uuid) in the hyphenated format.
1141        pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
1142        where
1143            S: serde_core::Serializer,
1144        {
1145            match u {
1146                Some(u) => serializer.serialize_some(u.as_hyphenated()),
1147                None => serializer.serialize_none(),
1148            }
1149        }
1150
1151        /// Deserialize an optional hyphenated string as an optional [`Uuid`](crate::Uuid).
1152        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
1153        where
1154            D: serde_core::Deserializer<'de>,
1155        {
1156            Option::<Hyphenated>::deserialize(deserializer).map(|u| u.map(Into::into))
1157        }
1158    }
1159
1160    #[cfg(test)]
1161    mod tests {
1162
1163        use serde::de::{self, Error};
1164        use serde_test::{Readable, Token};
1165
1166        use super::*;
1167
1168        const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1169        const BRACED_UUID_STR: &str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
1170
1171        #[test]
1172        fn test_hyphenated_option() {
1173            #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
1174            struct Field {
1175                #[serde(with = "crate::serde::hyphenated::option")]
1176                id: Option<Uuid>,
1177            }
1178
1179            let present = Field {
1180                id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
1181            };
1182            let absent = Field { id: None };
1183            let present_tokens = [
1184                Token::Struct {
1185                    name: "Field",
1186                    len: 1,
1187                },
1188                Token::Str("id"),
1189                Token::Some,
1190                Token::Str(HYPHENATED_UUID_STR),
1191                Token::StructEnd,
1192            ];
1193            let absent_tokens = [
1194                Token::Struct {
1195                    name: "Field",
1196                    len: 1,
1197                },
1198                Token::Str("id"),
1199                Token::None,
1200                Token::StructEnd,
1201            ];
1202
1203            serde_test::assert_tokens(&present, &present_tokens);
1204            serde_test::assert_tokens(&absent, &absent_tokens);
1205        }
1206
1207        #[test]
1208        fn test_serialize_as_hyphenated() {
1209            #[derive(serde_derive::Serialize)]
1210            struct Struct(#[serde(with = "super")] crate::Uuid);
1211
1212            let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1213            serde_test::assert_ser_tokens(
1214                &u,
1215                &[
1216                    Token::NewtypeStruct { name: "Struct" },
1217                    Token::Str(HYPHENATED_UUID_STR),
1218                ],
1219            );
1220        }
1221
1222        #[test]
1223        fn test_de_from_hyphenated() {
1224            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1225            struct Struct(#[serde(with = "super")] crate::Uuid);
1226            let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1227            serde_test::assert_de_tokens::<Struct>(
1228                &s,
1229                &[
1230                    Token::TupleStruct {
1231                        name: "Struct",
1232                        len: 1,
1233                    },
1234                    Token::BorrowedStr(HYPHENATED_UUID_STR),
1235                    Token::TupleStructEnd,
1236                ],
1237            );
1238        }
1239
1240        #[test]
1241        fn test_de_reject_braced() {
1242            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1243            struct Struct(#[serde(with = "super")] crate::Uuid);
1244            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1245                &[
1246                    Token::TupleStruct {
1247                        name: "Struct",
1248                        len: 1,
1249                    },
1250                    Token::BorrowedStr(BRACED_UUID_STR),
1251                    Token::TupleStructEnd,
1252                ],
1253                &format!(
1254                    "{}",
1255                    de::value::Error::custom(
1256                        "UUID parsing failed: invalid character: found `{` at 0"
1257                    )
1258                ),
1259            );
1260        }
1261
1262        #[test]
1263        fn test_de_reject_seq() {
1264            let uuid_bytes = b"F9168C5E-CEB2-4F";
1265
1266            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1267            struct Struct(#[serde(with = "super")] crate::Uuid);
1268            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1269                &[
1270                    Token::TupleStruct {
1271                        name: "Struct",
1272                        len: 1,
1273                    },
1274                    Token::Bytes(uuid_bytes),
1275                    Token::TupleStructEnd,
1276                ],
1277                &format!(
1278                    "{}",
1279                    de::value::Error::custom(
1280                        "invalid type: byte array, expected a UUID string in the hyphenated format"
1281                    )
1282                ),
1283            );
1284        }
1285    }
1286}
1287
1288/// Serialize a [`Uuid`] as [`uuid::fmt::Urn`](crate::fmt::Urn).
1289///
1290/// [`Uuid`]: ../../struct.Uuid.html
1291///
1292/// ## Examples
1293///
1294/// Serialize and deserialize using the URN format, failing to deserialize
1295/// any other format:
1296///
1297/// ```
1298/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
1299/// struct StructA {
1300///     #[serde(with = "uuid::serde::urn")]
1301///     id: uuid::Uuid,
1302/// }
1303/// ```
1304///
1305/// Serialize using the URN format, but deserialize any format:
1306///
1307/// ```
1308/// #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
1309/// struct StructB {
1310///     #[serde(serialize_with = "uuid::serde::urn::serialize")]
1311///     id: uuid::Uuid,
1312/// }
1313/// ```
1314pub mod urn {
1315    use super::*;
1316
1317    /// Serialize a [`Uuid`] as a URN string.
1318    ///
1319    /// [`Uuid`]: ../../struct.Uuid.html
1320    ///
1321    /// # Examples
1322    ///
1323    /// ```
1324    /// #[derive(serde_derive::Serialize)]
1325    /// struct Struct {
1326    ///     #[serde(serialize_with = "uuid::serde::urn::serialize")]
1327    ///     id: uuid::Uuid,
1328    /// }
1329    ///
1330    /// ```
1331    pub fn serialize<S>(u: &crate::Uuid, serializer: S) -> Result<S::Ok, S::Error>
1332    where
1333        S: serde_core::Serializer,
1334    {
1335        serde_core::Serialize::serialize(u.as_urn(), serializer)
1336    }
1337
1338    /// Deserialize a URN-formatted string as a [`Uuid`].
1339    ///
1340    /// [`Uuid`]: ../../struct.Uuid.html
1341    pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
1342    where
1343        D: serde_core::Deserializer<'de>,
1344    {
1345        Ok(Urn::deserialize(deserializer)?.into())
1346    }
1347
1348    /// Serialize and deserialize an optional [`Uuid`](crate::Uuid) in the URN format.
1349    pub mod option {
1350        use super::*;
1351
1352        /// Serialize an optional [`Uuid`](crate::Uuid) in the URN format.
1353        pub fn serialize<S>(u: &Option<Uuid>, serializer: S) -> Result<S::Ok, S::Error>
1354        where
1355            S: serde_core::Serializer,
1356        {
1357            match u {
1358                Some(u) => serializer.serialize_some(u.as_urn()),
1359                None => serializer.serialize_none(),
1360            }
1361        }
1362
1363        /// Deserialize an optional URN string as an optional [`Uuid`](crate::Uuid).
1364        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
1365        where
1366            D: serde_core::Deserializer<'de>,
1367        {
1368            Option::<Urn>::deserialize(deserializer).map(|u| u.map(Into::into))
1369        }
1370    }
1371
1372    #[cfg(test)]
1373    mod tests {
1374        use serde::de::{self, Error};
1375        use serde_test::{Readable, Token};
1376
1377        use super::*;
1378
1379        const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1380        const URN_UUID_STR: &str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1381
1382        #[test]
1383        fn test_urn_option() {
1384            #[derive(Debug, PartialEq, serde_derive::Serialize, serde_derive::Deserialize)]
1385            struct Field {
1386                #[serde(with = "crate::serde::urn::option")]
1387                id: Option<Uuid>,
1388            }
1389
1390            let present = Field {
1391                id: Some(HYPHENATED_UUID_STR.parse().unwrap()),
1392            };
1393            let absent = Field { id: None };
1394            let present_tokens = [
1395                Token::Struct {
1396                    name: "Field",
1397                    len: 1,
1398                },
1399                Token::Str("id"),
1400                Token::Some,
1401                Token::Str(URN_UUID_STR),
1402                Token::StructEnd,
1403            ];
1404            let absent_tokens = [
1405                Token::Struct {
1406                    name: "Field",
1407                    len: 1,
1408                },
1409                Token::Str("id"),
1410                Token::None,
1411                Token::StructEnd,
1412            ];
1413
1414            serde_test::assert_tokens(&present, &present_tokens);
1415            serde_test::assert_tokens(&absent, &absent_tokens);
1416        }
1417
1418        #[test]
1419        fn test_serialize_as_urn() {
1420            #[derive(serde_derive::Serialize)]
1421            struct Struct(#[serde(with = "super")] crate::Uuid);
1422
1423            let u = Struct(Uuid::parse_str(HYPHENATED_UUID_STR).unwrap());
1424            serde_test::assert_ser_tokens(
1425                &u,
1426                &[
1427                    Token::NewtypeStruct { name: "Struct" },
1428                    Token::Str(URN_UUID_STR),
1429                ],
1430            );
1431        }
1432
1433        #[test]
1434        fn test_de_from_urn() {
1435            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1436            struct Struct(#[serde(with = "super")] crate::Uuid);
1437            let s = Struct(HYPHENATED_UUID_STR.parse().unwrap());
1438            serde_test::assert_de_tokens::<Struct>(
1439                &s,
1440                &[
1441                    Token::TupleStruct {
1442                        name: "Struct",
1443                        len: 1,
1444                    },
1445                    Token::BorrowedStr(URN_UUID_STR),
1446                    Token::TupleStructEnd,
1447                ],
1448            );
1449        }
1450
1451        #[test]
1452        fn test_de_reject_hyphenated() {
1453            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1454            struct Struct(#[serde(with = "super")] crate::Uuid);
1455            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1456                &[
1457                    Token::TupleStruct {
1458                        name: "Struct",
1459                        len: 1,
1460                    },
1461                    Token::BorrowedStr(HYPHENATED_UUID_STR),
1462                    Token::TupleStructEnd,
1463                ],
1464                &format!(
1465                    "{}",
1466                    de::value::Error::custom(
1467                        "UUID parsing failed: invalid character: found `f` at 0"
1468                    )
1469                ),
1470            );
1471        }
1472
1473        #[test]
1474        fn test_de_reject_seq() {
1475            let uuid_bytes = b"F9168C5E-CEB2-4F";
1476
1477            #[derive(PartialEq, Debug, serde_derive::Deserialize)]
1478            struct Struct(#[serde(with = "super")] crate::Uuid);
1479            serde_test::assert_de_tokens_error::<Readable<Struct>>(
1480                &[
1481                    Token::TupleStruct {
1482                        name: "Struct",
1483                        len: 1,
1484                    },
1485                    Token::Bytes(uuid_bytes),
1486                    Token::TupleStructEnd,
1487                ],
1488                &format!(
1489                    "{}",
1490                    de::value::Error::custom(
1491                        "invalid type: byte array, expected a UUID string in the URN format"
1492                    )
1493                ),
1494            );
1495        }
1496    }
1497}
1498
1499#[cfg(test)]
1500mod serde_tests {
1501    use super::*;
1502
1503    use serde_test::{Compact, Configure, Readable, Token};
1504
1505    #[test]
1506    fn test_serialize_readable_string() {
1507        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1508        let u = Uuid::parse_str(uuid_str).unwrap();
1509        serde_test::assert_tokens(&u.readable(), &[Token::Str(uuid_str)]);
1510    }
1511
1512    #[test]
1513    fn test_deserialize_readable_compact() {
1514        let uuid_bytes = b"F9168C5E-CEB2-4F";
1515        let u = Uuid::from_slice(uuid_bytes).unwrap();
1516
1517        serde_test::assert_de_tokens(
1518            &u.readable(),
1519            &[
1520                Token::Tuple { len: 16 },
1521                Token::U8(uuid_bytes[0]),
1522                Token::U8(uuid_bytes[1]),
1523                Token::U8(uuid_bytes[2]),
1524                Token::U8(uuid_bytes[3]),
1525                Token::U8(uuid_bytes[4]),
1526                Token::U8(uuid_bytes[5]),
1527                Token::U8(uuid_bytes[6]),
1528                Token::U8(uuid_bytes[7]),
1529                Token::U8(uuid_bytes[8]),
1530                Token::U8(uuid_bytes[9]),
1531                Token::U8(uuid_bytes[10]),
1532                Token::U8(uuid_bytes[11]),
1533                Token::U8(uuid_bytes[12]),
1534                Token::U8(uuid_bytes[13]),
1535                Token::U8(uuid_bytes[14]),
1536                Token::U8(uuid_bytes[15]),
1537                Token::TupleEnd,
1538            ],
1539        );
1540    }
1541
1542    #[test]
1543    fn test_deserialize_readable_bytes() {
1544        let uuid_bytes = b"F9168C5E-CEB2-4F";
1545        let u = Uuid::from_slice(uuid_bytes).unwrap();
1546
1547        serde_test::assert_de_tokens(&u.readable(), &[serde_test::Token::Bytes(uuid_bytes)]);
1548    }
1549
1550    #[test]
1551    fn test_serialize_hyphenated() {
1552        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1553        let u = Uuid::parse_str(uuid_str).unwrap();
1554        serde_test::assert_ser_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
1555        serde_test::assert_de_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
1556    }
1557
1558    #[test]
1559    fn test_serialize_simple() {
1560        let uuid_str = "f9168c5eceb24faab6bf329bf39fa1e4";
1561        let u = Uuid::parse_str(uuid_str).unwrap();
1562        serde_test::assert_ser_tokens(&u.simple(), &[Token::Str(uuid_str)]);
1563        serde_test::assert_de_tokens(&u.simple(), &[Token::Str(uuid_str)]);
1564    }
1565
1566    #[test]
1567    fn test_serialize_urn() {
1568        let uuid_str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1569        let u = Uuid::parse_str(uuid_str).unwrap();
1570        serde_test::assert_ser_tokens(&u.urn(), &[Token::Str(uuid_str)]);
1571        serde_test::assert_de_tokens(&u.urn(), &[Token::Str(uuid_str)]);
1572    }
1573
1574    #[test]
1575    fn test_serialize_braced() {
1576        let uuid_str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
1577        let u = Uuid::parse_str(uuid_str).unwrap();
1578        serde_test::assert_ser_tokens(&u.braced(), &[Token::Str(uuid_str)]);
1579        serde_test::assert_de_tokens(&u.braced(), &[Token::Str(uuid_str)]);
1580    }
1581
1582    #[test]
1583    fn test_serialize_non_human_readable() {
1584        let uuid_bytes = b"F9168C5E-CEB2-4F";
1585        let u = Uuid::from_slice(uuid_bytes).unwrap();
1586        serde_test::assert_tokens(
1587            &u.compact(),
1588            &[serde_test::Token::Bytes(&[
1589                70, 57, 49, 54, 56, 67, 53, 69, 45, 67, 69, 66, 50, 45, 52, 70,
1590            ])],
1591        );
1592    }
1593
1594    #[test]
1595    fn test_de_failure() {
1596        serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1597            &[Token::Str("hello_world")],
1598            "UUID parsing failed: invalid character: found `h` at 0",
1599        );
1600
1601        serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1602            &[Token::Bytes(b"hello_world")],
1603            "UUID parsing failed: invalid length: expected 16 bytes, found 11",
1604        );
1605
1606        serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1607            &[
1608                Token::Tuple { len: 2 },
1609                Token::U8(70),
1610                Token::U8(57),
1611                Token::TupleEnd,
1612            ],
1613            "invalid length 2, expected a 16 byte array",
1614        );
1615
1616        serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1617            &[
1618                Token::Tuple { len: 2 },
1619                Token::U8(70),
1620                Token::U8(57),
1621                Token::TupleEnd,
1622            ],
1623            "invalid length 2, expected a 16 byte array",
1624        );
1625
1626        serde_test::assert_de_tokens_error::<Readable<Uuid>>(
1627            &[
1628                Token::Tuple { len: 17 },
1629                Token::U8(70),
1630                Token::U8(57),
1631                Token::U8(49),
1632                Token::U8(54),
1633                Token::U8(56),
1634                Token::U8(67),
1635                Token::U8(53),
1636                Token::U8(69),
1637                Token::U8(45),
1638                Token::U8(67),
1639                Token::U8(69),
1640                Token::U8(66),
1641                Token::U8(50),
1642                Token::U8(45),
1643                Token::U8(52),
1644                Token::U8(70),
1645                Token::U8(70),
1646                Token::TupleEnd,
1647            ],
1648            "invalid length 17, expected a 16 byte array",
1649        );
1650
1651        serde_test::assert_de_tokens_error::<Compact<Uuid>>(
1652            &[
1653                Token::Tuple { len: 17 },
1654                Token::U8(70),
1655                Token::U8(57),
1656                Token::U8(49),
1657                Token::U8(54),
1658                Token::U8(56),
1659                Token::U8(67),
1660                Token::U8(53),
1661                Token::U8(69),
1662                Token::U8(45),
1663                Token::U8(67),
1664                Token::U8(69),
1665                Token::U8(66),
1666                Token::U8(50),
1667                Token::U8(45),
1668                Token::U8(52),
1669                Token::U8(70),
1670                Token::U8(70),
1671                Token::TupleEnd,
1672            ],
1673            "invalid length 17, expected a 16 byte array",
1674        );
1675    }
1676
1677    #[test]
1678    fn test_serde_non_nil_uuid() {
1679        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
1680        let uuid = Uuid::parse_str(uuid_str).unwrap();
1681        let non_nil_uuid = NonNilUuid::try_from(uuid).unwrap();
1682
1683        serde_test::assert_ser_tokens(&non_nil_uuid.readable(), &[Token::Str(uuid_str)]);
1684        serde_test::assert_de_tokens(&non_nil_uuid.readable(), &[Token::Str(uuid_str)]);
1685    }
1686}