/rust/registry/src/index.crates.io-6f17d22bba15001f/revision-0.10.0/src/implementations/tuple.rs

Source (jump to first uncovered line)
use super::super::Error;
use super::super::Revisioned;

macro_rules! impl_tuple {
  ($($n:ident),*$(,)?) => {
    impl_tuple!{@marker $($n,)*}
  };

  ($($n:ident,)* @marker $head:ident, $($tail:ident,)*) => {
    impl<$($n),*> Revisioned for ($($n,)*)
      where $($n: Revisioned),*
    {
      fn revision() -> u16{
        1
      }

      #[inline]
      #[allow(non_snake_case)]
      fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
        let ($(ref $n,)*) = *self;
        $(
          $n.serialize_revisioned(_writer)?;
        )*
        Ok(())
      }

      #[inline]
      #[allow(non_snake_case)]
      fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
        $(
          let $n = Revisioned::deserialize_revisioned(_reader)?;
        )*
        Ok(($($n,)*))
      }
    }

    impl_tuple!{$($n,)* $head, @marker $($tail,)*}

  };
  ($($n:ident,)* @marker) => {
    impl<$($n),*> Revisioned for ($($n),*)
      where $($n: Revisioned),*
    {
      fn revision() -> u16{
        1
      }

      #[inline]
      #[allow(non_snake_case)]
      fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
        let ($(ref $n),*) = self;
        $(
          $n.serialize_revisioned(_writer)?;
        )*
        Ok(())
      }

      #[inline]
      #[allow(non_snake_case)]
      fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
        $(
          let $n = Revisioned::deserialize_revisioned(_reader)?;
        )*
        Ok(($($n),*))
      }
    }
  };
}

impl_tuple! { A,B,C,D,E,F }

#[cfg(test)]
mod tests {

  use crate::implementations::assert_bincode_compat;

  use super::Revisioned;

  #[test]
  fn test_tuple_2() {
    let val = (String::from("test"), true);
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 6);
    let out =
      <(String, bool) as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_3() {
    let val = (String::from("test"), true, 1419247293847192847.13947134978139487);
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 14);
    let out = <(String, bool, f64) as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
      .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_4() {
    let val = (String::from("test"), true, 1419247293847192847.13947134978139487, Some('t'));
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 16);
    let out = <(String, bool, f64, Option<char>) as Revisioned>::deserialize_revisioned(
      &mut mem.as_slice(),
    )
    .unwrap();
    assert_eq!(val, out);
  }

  #[test]
  fn test_tuple_5() {
    let val = (
      String::from("test"),
      true,
      1419247293847192847.13947134978139487,
      Some('t'),
      vec![4u8, 19u8, 133u8],
    );
    assert_bincode_compat(&val);
    let mut mem: Vec<u8> = vec![];
    val.serialize_revisioned(&mut mem).unwrap();
    assert_eq!(mem.len(), 20);
    let out =
      <(String, bool, f64, Option<char>, Vec<u8>) as Revisioned>::deserialize_revisioned(
        &mut mem.as_slice(),
      )
      .unwrap();
    assert_eq!(val, out);
  }
}

Coverage Report

Created: 2025-02-21 07:11

Line	Count	Source (jump to first uncovered line)
1		use super::super::Error;
2		use super::super::Revisioned;
3
4		macro_rules! impl_tuple {
5		($($n:ident),*$(,)?) => {
6		impl_tuple!{@marker $($n,)*}
7		};
8
9		($($n:ident,)* @marker $head:ident, $($tail:ident,)*) => {
10		impl<$($n),> Revisioned for ($($n,))
11		where $($n: Revisioned),*
12		{
13	0	fn revision() -> u16{
14	0	1
15	0	} Unexecuted instantiation: <() as revision::Revisioned>::revision Unexecuted instantiation: <(_,) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _, _) as revision::Revisioned>::revision Unexecuted instantiation: <(_, _, _, _, _) as revision::Revisioned>::revision
16
17		#[inline]
18		#[allow(non_snake_case)]
19	0	fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
20	0	let ($(ref $n,)) = self;
21	0	$(
22	0	$n.serialize_revisioned(_writer)?;
23	0	)*
24	0	Ok(())
25	0	} Unexecuted instantiation: <() as revision::Revisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_,) as revision::Revisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _) as revision::Revisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _) as revision::Revisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _) as revision::Revisioned>::serialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _, _) as revision::Revisioned>::serialize_revisioned::<_>
26
27		#[inline]
28		#[allow(non_snake_case)]
29	0	fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
30	0	$(
31	0	let $n = Revisioned::deserialize_revisioned(_reader)?;
32	0	)*
33	0	Ok(($($n,)*))
34	0	} Unexecuted instantiation: <() as revision::Revisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_,) as revision::Revisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _) as revision::Revisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _) as revision::Revisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _) as revision::Revisioned>::deserialize_revisioned::<_> Unexecuted instantiation: <(_, _, _, _, _) as revision::Revisioned>::deserialize_revisioned::<_>
35		}
36
37		impl_tuple!{$($n,)* $head, @marker $($tail,)*}
38
39		};
40		($($n:ident,)* @marker) => {
41		impl<$($n),> Revisioned for ($($n),)
42		where $($n: Revisioned),*
43		{
44	0	fn revision() -> u16{
45	0	1
46	0	}
47
48		#[inline]
49		#[allow(non_snake_case)]
50	0	fn serialize_revisioned<W: std::io::Write>(&self, _writer: &mut W) -> Result<(), Error> {
51	0	let ($(ref $n),*) = self;
52		$(
53	0	$n.serialize_revisioned(_writer)?;
54		)*
55	0	Ok(())
56	0	}
57
58		#[inline]
59		#[allow(non_snake_case)]
60	0	fn deserialize_revisioned<R: std::io::Read>(_reader: &mut R) -> Result<Self, Error> {
61		$(
62	0	let $n = Revisioned::deserialize_revisioned(_reader)?;
63		)*
64	0	Ok(($($n),*))
65	0	}
66		}
67		};
68		}
69
70		impl_tuple! { A,B,C,D,E,F }
71
72		#[cfg(test)]
73		mod tests {
74
75		use crate::implementations::assert_bincode_compat;
76
77		use super::Revisioned;
78
79		#[test]
80		fn test_tuple_2() {
81		let val = (String::from("test"), true);
82		assert_bincode_compat(&val);
83		let mut mem: Vec<u8> = vec![];
84		val.serialize_revisioned(&mut mem).unwrap();
85		assert_eq!(mem.len(), 6);
86		let out =
87		<(String, bool) as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
88		assert_eq!(val, out);
89		}
90
91		#[test]
92		fn test_tuple_3() {
93		let val = (String::from("test"), true, 1419247293847192847.13947134978139487);
94		assert_bincode_compat(&val);
95		let mut mem: Vec<u8> = vec![];
96		val.serialize_revisioned(&mut mem).unwrap();
97		assert_eq!(mem.len(), 14);
98		let out = <(String, bool, f64) as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
99		.unwrap();
100		assert_eq!(val, out);
101		}
102
103		#[test]
104		fn test_tuple_4() {
105		let val = (String::from("test"), true, 1419247293847192847.13947134978139487, Some('t'));
106		assert_bincode_compat(&val);
107		let mut mem: Vec<u8> = vec![];
108		val.serialize_revisioned(&mut mem).unwrap();
109		assert_eq!(mem.len(), 16);
110		let out = <(String, bool, f64, Option<char>) as Revisioned>::deserialize_revisioned(
111		&mut mem.as_slice(),
112		)
113		.unwrap();
114		assert_eq!(val, out);
115		}
116
117		#[test]
118		fn test_tuple_5() {
119		let val = (
120		String::from("test"),
121		true,
122		1419247293847192847.13947134978139487,
123		Some('t'),
124		vec![4u8, 19u8, 133u8],
125		);
126		assert_bincode_compat(&val);
127		let mut mem: Vec<u8> = vec![];
128		val.serialize_revisioned(&mut mem).unwrap();
129		assert_eq!(mem.len(), 20);
130		let out =
131		<(String, bool, f64, Option<char>, Vec<u8>) as Revisioned>::deserialize_revisioned(
132		&mut mem.as_slice(),
133		)
134		.unwrap();
135		assert_eq!(val, out);
136		}
137		}