feat(nom5): change (String, ErrorKind) to (Vec<u8>, ErrorKind) of Deserialize error kind

NamsooCho · NamsooCho · commit 4101682b1e19 · 2019-06-24T10:24:40.000+09:00
diff --git a/src/toxcore/binary_io.rs b/src/toxcore/binary_io.rs
@@ -72,11 +72,6 @@ impl ToBytes for Ipv6Addr {
     }
 }
 
-/// Parser that returns the length of the remaining input.
-pub fn rest_len(input: &[u8]) -> IResult<&[u8], usize> {
-    Ok((input, input.len()))
-}
-
 /// Generator that ensures that length of serialized data does not exceed specified limit.
 pub fn gen_len_limit(buf: (&mut [u8], usize), limit: usize) -> Result<(&mut [u8], usize), GenError> {
     if buf.1 <= limit {
diff --git a/src/toxcore/dht/codec.rs b/src/toxcore/dht/codec.rs
@@ -10,9 +10,7 @@ use crate::toxcore::stats::*;
 use bytes::BytesMut;
 use cookie_factory::GenError;
 use failure::Fail;
-use nom::{error::ErrorKind, Err,
-          Needed
-};
+use nom::{error::ErrorKind, Err};
 use tokio::codec::{Decoder, Encoder};
 
 /// A serialized `Packet` should be not longer than 2048 bytes.
@@ -23,27 +21,19 @@ error_kind! {
     #[derive(Debug)]
     DecodeError,
     #[doc = "Error that can happen when decoding `Packet` from bytes."]
-    #[derive(Clone, Debug, Eq, PartialEq, Fail)]
+    #[derive(Clone, Debug, PartialEq, Fail)]
     DecodeErrorKind {
         #[doc = "Error indicates that we received too big packet."]
         #[fail(display = "Packet should not be longer than 2048 bytes: {} bytes", len)]
         TooBigPacket {
             #[doc = "Length of received packet."]
             len: usize
         },
-        #[doc = "Error indicates that more data is needed to parse received packet."]
-        #[fail(display = "Packet should not be incomplete: {:?}, packet: {:?}", needed, packet)]
-        IncompletePacket {
-            #[doc = "Required data size to be parsed."]
-            needed: Needed,
-            #[doc = "Received packet."]
-            packet: Vec<u8>,
-        },
         #[doc = "Error indicates that received packet can't be parsed."]
         #[fail(display = "Deserialize Packet error: {:?}, packet: {:?}", error, packet)]
         Deserialize {
             #[doc = "Parsing error."]
-            error: ErrorKind,
+            error: nom::Err<(Vec<u8>, ErrorKind)>,
             #[doc = "Received packet."]
             packet: Vec<u8>,
         },
@@ -58,11 +48,13 @@ impl DecodeError {
         DecodeError::from(DecodeErrorKind::TooBigPacket { len })
     }
 
-    pub(crate) fn incomplete_packet(needed: Needed, packet: Vec<u8>) -> DecodeError {
-        DecodeError::from(DecodeErrorKind::IncompletePacket { needed, packet })
-    }
+    pub(crate) fn deserialize(e: Err<(&[u8], ErrorKind)>, packet: Vec<u8>) -> DecodeError {
+        let error = match e {
+            Err::Error(e) => Err::Error((e.0.to_vec(), e.1)),
+            Err::Failure(e) => Err::Failure((e.0.to_vec(), e.1)),
+            Err::Incomplete(needed) => Err::Incomplete(needed),
+        };
 
-    pub(crate) fn deserialize(error: ErrorKind, packet: Vec<u8>) -> DecodeError {
         DecodeError::from(DecodeErrorKind::Deserialize { error, packet })
     }
 }
@@ -134,14 +126,8 @@ impl Decoder for DhtCodec {
         }
 
         match Packet::from_bytes(buf) {
-            Err(Err::Incomplete(needed)) => Err(DecodeError::incomplete_packet(needed, buf.to_vec())),
-            Err(Err::Error(error)) => {
-                let (_, kind) = error;
-                Err(DecodeError::deserialize(kind, buf.to_vec()))
-            },
-            Err(Err::Failure(error)) => {
-                let (_, kind) = error;
-                Err(DecodeError::deserialize(kind, buf.to_vec()))
+            Err(error) => {
+                Err(DecodeError::deserialize(error, buf.to_vec()))
             },
             Ok((_, packet)) => {
                 // Add 1 to incoming counter
@@ -175,6 +161,7 @@ impl Encoder for DhtCodec {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use nom::Needed;
     use crate::toxcore::onion::packet::*;
     use crate::toxcore::crypto_core::*;
 
@@ -356,8 +343,8 @@ mod tests {
 
         let res = codec.decode(&mut buf);
         // not enought bytes to decode EncryptedPacket
-        assert!(res.is_err());
-        assert_eq!(*res.err().unwrap().kind(), DecodeErrorKind::Deserialize { error: ErrorKind::Alt, packet: vec![0xff] });
+        let error = res.err().unwrap();
+        assert_eq!(*error.kind(), DecodeErrorKind::Deserialize { error: Err::Error((vec![255], ErrorKind::Alt)) , packet: vec![0xff] });
     }
 
     #[test]
@@ -369,8 +356,8 @@ mod tests {
 
         // not enought bytes to decode EncryptedPacket
         let res = codec.decode(&mut buf);
-        assert!(res.is_err());
-        assert_eq!(*res.err().unwrap().kind(), DecodeErrorKind::IncompletePacket { needed: Needed::Size(1), packet: Vec::new() });
+        let error = res.err().unwrap();
+        assert_eq!(*error.kind(), DecodeErrorKind::Deserialize { error: Err::Incomplete(Needed::Size(1)), packet: Vec::new() });
     }
 
     #[test]
diff --git a/src/toxcore/dht/daemon_state.rs b/src/toxcore/dht/daemon_state.rs
@@ -15,42 +15,34 @@ use crate::toxcore::dht::kbucket::*;
 use crate::toxcore::dht::ktree::*;
 
 use failure::Fail;
-use nom::{Needed, Err,
-          error::ErrorKind as NomErrorKind
-};
+use nom::{Err, error::ErrorKind as NomErrorKind};
 
 error_kind! {
     #[doc = "An error that can occur while serializing/deserializing object."]
     #[derive(Debug)]
     DeserializeError,
     #[doc = "The specific kind of error that can occur."]
-    #[derive(Clone, Debug, Eq, PartialEq, Fail)]
+    #[derive(Clone, Debug, PartialEq, Fail)]
     DeserializeErrorKind {
         #[doc = "Error indicates that object can't be parsed."]
         #[fail(display = "Deserialize object error: {:?}, data: {:?}", error, data)]
         Deserialize {
             #[doc = "Parsing error."]
-            error: NomErrorKind,
-            #[doc = "Object serialized data."]
-            data: Vec<u8>,
-        },
-        #[doc = "Error indicates that more data is needed to parse serialized object."]
-        #[fail(display = "Bytes of object should not be incomplete: {:?}, data: {:?}", needed, data)]
-        IncompleteData {
-            #[doc = "Required data size to be parsed."]
-            needed: Needed,
+            error: nom::Err<(Vec<u8>, NomErrorKind)>,
             #[doc = "Object serialized data."]
             data: Vec<u8>,
         },
     }
 }
 
 impl DeserializeError {
-    pub(crate) fn incomplete(needed: Needed, data: Vec<u8>) -> DeserializeError {
-        DeserializeError::from(DeserializeErrorKind::IncompleteData { needed, data })
-    }
+    pub(crate) fn deserialize(e: Err<(&[u8], NomErrorKind)>, data: Vec<u8>) -> DeserializeError {
+        let error = match e {
+            Err::Error(e) => Err::Error((e.0.to_vec(), e.1)),
+            Err::Failure(e) => Err::Failure((e.0.to_vec(), e.1)),
+            Err::Incomplete(needed) => Err::Incomplete(needed),
+        };
 
-    pub(crate) fn deserialize(error: NomErrorKind, data: Vec<u8>) -> DeserializeError {
         DeserializeError::from(DeserializeErrorKind::Deserialize { error, data })
     }
 }
@@ -88,16 +80,8 @@ impl DaemonState {
     /// Deserialize DHT close list and then re-setup close list, old means that the format of deserialization is old version
     pub fn deserialize_old(server: &Server, serialized_data: &[u8]) -> impl Future<Item=(), Error=DeserializeError> + Send {
         let nodes = match DhtState::from_bytes(serialized_data) {
-            Err(Err::Incomplete(needed)) => {
-                return Either::A(future::err(DeserializeError::incomplete(needed, serialized_data.to_vec())))
-            },
-            Err(Err::Error(error)) => {
-                let (_, kind) = error;
-                return Either::A(future::err(DeserializeError::deserialize(kind, serialized_data.to_vec())))
-            },
-            Err(Err::Failure(error)) => {
-                let (_, kind) = error;
-                return Either::A(future::err(DeserializeError::deserialize(kind, serialized_data.to_vec())))
+            Err(error) => {
+                return Either::A(future::err(DeserializeError::deserialize(error, serialized_data.to_vec())))
             },
             Ok((_, DhtState(nodes))) => {
                 nodes
@@ -158,14 +142,14 @@ mod tests {
         let serialized_vec = DaemonState::serialize_old(&alice);
         let serialized_len = serialized_vec.len();
         let res = DaemonState::deserialize_old(&alice, &serialized_vec[..serialized_len - 1]).wait();
-        let error = res.err().unwrap();
-        assert_eq!(*error.kind(), DeserializeErrorKind::Deserialize { error: NomErrorKind::Eof, data: serialized_vec[..serialized_len - 1].to_vec() });
+        res.err().unwrap();
 
         // test with serialized data corrupted
         let serialized_vec = [42; 10];
         let res = DaemonState::deserialize_old(&alice, &serialized_vec).wait();
         let error = res.err().unwrap();
-        assert_eq!(*error.kind(), DeserializeErrorKind::Deserialize { error: NomErrorKind::Tag, data: serialized_vec.to_vec() });
+        assert_eq!(*error.kind(), DeserializeErrorKind::Deserialize { error: Err::Error((
+            vec![42, 42, 42, 42, 42, 42, 42, 42, 42, 42], NomErrorKind::Tag)), data: serialized_vec.to_vec() });
 
         // test with empty close list
         alice.close_nodes.write().remove(&pk_org);
diff --git a/src/toxcore/dht/packet/cookie.rs b/src/toxcore/dht/packet/cookie.rs
@@ -234,7 +234,10 @@ mod tests {
         let decoded_payload = invalid_encrypted_cookie.get_payload(&symmetric_key);
         let error = decoded_payload.err().unwrap();
         assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize {
-            error: Err::Error(("***************************************************".to_owned(), ErrorKind::Eof)),
+            error: Err::Error((vec![42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                    42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                    42, 42, 42], ErrorKind::Eof)),
             payload: invalid_payload.to_vec()
         });
         // Try short incomplete array
@@ -247,7 +250,7 @@ mod tests {
         let decoded_payload = invalid_encrypted_cookie.get_payload(&symmetric_key);
         let error = decoded_payload.err().unwrap();
         assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize {
-            error: Err::Error(("**".to_owned(), ErrorKind::Eof)),
+            error: Err::Error((vec![42, 42], ErrorKind::Eof)),
             payload: invalid_payload.to_vec()
         });
     }
diff --git a/src/toxcore/dht/packet/cookie_response.rs b/src/toxcore/dht/packet/cookie_response.rs
@@ -213,7 +213,7 @@ mod tests {
         let decoded_payload = invalid_packet.get_payload(&shared_secret);
         let error = decoded_payload.err().unwrap();
         assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize {
-            error: Err::Error(("***".to_owned(), ErrorKind::Eof)),
+            error: Err::Error((vec![42, 42, 42], ErrorKind::Eof)),
             payload: invalid_payload.to_vec()
         });
         // Try short incomplete array
diff --git a/src/toxcore/dht/packet/crypto_data.rs b/src/toxcore/dht/packet/crypto_data.rs
@@ -3,7 +3,7 @@
 
 use byteorder::{ByteOrder, BigEndian};
 use nom::{number::complete::{be_u16, be_u32},
-          combinator::rest,
+          combinator::{rest, rest_len},
 };
 
 use crate::toxcore::binary_io::*;
@@ -236,6 +236,6 @@ mod tests {
         };
         let decoded_payload = invalid_packet.get_payload(&shared_secret, &nonce);
         let error = decoded_payload.err().unwrap();
-        assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize { error: Err::Error(("".to_owned(), ErrorKind::Eof)), payload: invalid_payload.to_vec() });
+        assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize { error: Err::Error((vec![], ErrorKind::Eof)), payload: invalid_payload.to_vec() });
     }
 }
diff --git a/src/toxcore/dht/packet/dht_request.rs b/src/toxcore/dht/packet/dht_request.rs
@@ -591,7 +591,7 @@ mod tests {
         let decoded_payload = invalid_packet.get_payload(&precomputed_key);
         let error = decoded_payload.err().unwrap();
         assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize {
-            error: Err::Error(("***************************************************************************************************************************".to_owned(), ErrorKind::Alt)),
+            error: Err::Error((invalid_payload.to_vec(), ErrorKind::Alt)),
             payload: invalid_payload.to_vec()
         });
         // Try short incomplete
diff --git a/src/toxcore/dht/packet/errors.rs b/src/toxcore/dht/packet/errors.rs
@@ -29,8 +29,8 @@ impl GetPayloadError {
 
     pub(crate) fn deserialize(e: Err<(&[u8], ErrorKind)>, payload: Vec<u8>) -> GetPayloadError {
         let error = match e {
-            Err::Error(e) => Err::Error((String::from_utf8_lossy(e.0).to_string(), e.1)),
-            Err::Failure(e) => Err::Failure((String::from_utf8_lossy(e.0).to_string(), e.1)),
+            Err::Error(e) => Err::Error((e.0.to_vec(), e.1)),
+            Err::Failure(e) => Err::Failure((e.0.to_vec(), e.1)),
             Err::Incomplete(needed) => Err::Incomplete(needed),
         };
 
@@ -64,7 +64,7 @@ pub enum GetPayloadErrorKind {
     #[fail(display = "Deserialize payload error: {:?}, data: {:?}", error, payload)]
     Deserialize {
         /// Parsing error
-        error: nom::Err<(String, ErrorKind)>,
+        error: nom::Err<(Vec<u8>, ErrorKind)>,
         /// Received payload of packet
         payload: Vec<u8>,
     }
@@ -99,7 +99,7 @@ mod tests {
         let error = GetPayloadError::deserialize(Err::Error((&[], ErrorKind::Eof)), vec![1, 2, 3, 4]);
         assert!(error.cause().is_none());
         assert!(error.backtrace().is_some());
-        assert_eq!(format!("{}", error), "Deserialize payload error: Error((\"\", Eof)), data: [1, 2, 3, 4]".to_owned());
+        assert_eq!(format!("{}", error), "Deserialize payload error: Error(([], Eof)), data: [1, 2, 3, 4]".to_owned());
     }
 
     #[test]
@@ -110,7 +110,7 @@ mod tests {
         let incomplete = GetPayloadErrorKind::Deserialize { error: Err::Incomplete(Needed::Size(5)), payload: vec![1, 2, 3, 4] };
         assert_eq!(format!("{}", incomplete), "Deserialize payload error: Incomplete(Size(5)), data: [1, 2, 3, 4]".to_owned());
 
-        let deserialize = GetPayloadErrorKind::Deserialize { error: Err::Error(("".to_owned(), ErrorKind::Eof)), payload: vec![1, 2, 3, 4] };
-        assert_eq!(format!("{}", deserialize), "Deserialize payload error: Error((\"\", Eof)), data: [1, 2, 3, 4]".to_owned());
+        let deserialize = GetPayloadErrorKind::Deserialize { error: Err::Error((vec![], ErrorKind::Eof)), payload: vec![1, 2, 3, 4] };
+        assert_eq!(format!("{}", deserialize), "Deserialize payload error: Error(([], Eof)), data: [1, 2, 3, 4]".to_owned());
     }
 }
diff --git a/src/toxcore/dht/packet/nodes_response.rs b/src/toxcore/dht/packet/nodes_response.rs
@@ -141,11 +141,8 @@ impl ToBytes for NodesResponsePayload {
 
 impl FromBytes for NodesResponsePayload {
     named!(from_bytes<NodesResponsePayload>, do_parse!(
-        nodes_number: le_u8 >>
-        nodes: map_opt!(cond!(
-            nodes_number <= 4,
-            count!(PackedNode::from_bytes, nodes_number as usize)
-        ), |nodes| nodes) >>
+        nodes_number: verify!(le_u8, |len| *len <= 4) >>
+        nodes: count!(PackedNode::from_bytes, nodes_number as usize) >>
         id: be_u64 >>
         eof!() >>
         (NodesResponsePayload { nodes, id })
diff --git a/src/toxcore/messenger/file_transfer/packet/file_data.rs b/src/toxcore/messenger/file_transfer/packet/file_data.rs
@@ -3,7 +3,7 @@ It is used to transfer chunk of file data to a friend.
 */
 
 use nom::{AsBytes,
-          combinator::rest,
+          combinator::{rest, rest_len},
           number::complete::le_u8,
 };
 
diff --git a/src/toxcore/messenger/packet/msi.rs b/src/toxcore/messenger/packet/msi.rs
@@ -3,6 +3,7 @@
 
 use nom::{Err, error::ErrorKind,
           number::complete::le_u8,
+          combinator::rest_len
 };
 use bitflags::*;
 
diff --git a/src/toxcore/onion/packet/mod.rs b/src/toxcore/onion/packet/mod.rs
@@ -36,7 +36,7 @@ use crate::toxcore::ip_port::*;
 
 use nom::{Err,
           number::complete::le_u8,
-          combinator::rest,
+          combinator::{rest, rest_len},
 };
 use std::io::{Error, ErrorKind};
 
diff --git a/src/toxcore/onion/packet/onion_announce_request.rs b/src/toxcore/onion/packet/onion_announce_request.rs
@@ -8,7 +8,8 @@ use crate::toxcore::crypto_core::*;
 use crate::toxcore::dht::packet::*;
 
 use nom::{number::complete::le_u64,
-          combinator::rest,
+          combinator::{rest, rest_len},
+          bytes::complete::take
 };
 
 /** It's used for announcing ourselves to onion node and for looking for other
@@ -136,11 +137,8 @@ pub struct OnionAnnounceRequest {
 
 impl FromBytes for OnionAnnounceRequest {
     named!(from_bytes<OnionAnnounceRequest>, do_parse!(
-        rest_len: verify!(rest_len, |len| *len <= ONION_MAX_PACKET_SIZE) >>
-        inner: map_opt!(cond!(
-            rest_len >= ONION_RETURN_3_SIZE,
-            flat_map!(take!(rest_len - ONION_RETURN_3_SIZE), InnerOnionAnnounceRequest::from_bytes)
-        ), |inner: Option<InnerOnionAnnounceRequest>| inner) >>
+        rest_len: verify!(rest_len, |len| *len <= ONION_MAX_PACKET_SIZE && *len >= ONION_RETURN_3_SIZE) >>
+        inner: flat_map!(take(rest_len - ONION_RETURN_3_SIZE), InnerOnionAnnounceRequest::from_bytes) >>
         onion_return: call!(OnionReturn::from_bytes) >>
         (OnionAnnounceRequest { inner, onion_return })
     ));
diff --git a/src/toxcore/onion/packet/onion_announce_response.rs b/src/toxcore/onion/packet/onion_announce_response.rs
@@ -8,7 +8,7 @@ use crate::toxcore::crypto_core::*;
 use crate::toxcore::dht::packet::*;
 
 use nom::{number::complete::le_u64,
-          combinator::rest,
+          combinator::{rest, rest_len},
 };
 
 /** It's used to respond to `OnionAnnounceRequest` packet.
diff --git a/src/toxcore/onion/packet/onion_data_request.rs b/src/toxcore/onion/packet/onion_data_request.rs
@@ -8,7 +8,9 @@ use crate::toxcore::crypto_core::*;
 use crate::toxcore::dht::packet::*;
 use crate::toxcore::onion::packet::MAX_ONION_RESPONSE_PAYLOAD_SIZE;
 
-use nom::combinator::rest;
+use nom::{combinator::{rest, rest_len},
+          bytes::complete::take
+};
 
 /** It's used to send data requests to dht node using onion paths.
 
@@ -140,11 +142,8 @@ pub struct OnionDataRequest {
 
 impl FromBytes for OnionDataRequest {
     named!(from_bytes<OnionDataRequest>, do_parse!(
-        rest_len: verify!(rest_len, |len| *len <= ONION_MAX_PACKET_SIZE) >>
-        inner: map_opt!(cond!(
-            rest_len >= ONION_RETURN_3_SIZE,
-            flat_map!(take!(rest_len - ONION_RETURN_3_SIZE), InnerOnionDataRequest::from_bytes)
-        ), |inner| inner) >>
+        rest_len: verify!(rest_len, |len| *len <= ONION_MAX_PACKET_SIZE && *len >= ONION_RETURN_3_SIZE) >>
+        inner: flat_map!(take(rest_len - ONION_RETURN_3_SIZE), InnerOnionDataRequest::from_bytes) >>
         onion_return: call!(OnionReturn::from_bytes) >>
         (OnionDataRequest { inner, onion_return })
     ));
diff --git a/src/toxcore/onion/packet/onion_data_response.rs b/src/toxcore/onion/packet/onion_data_response.rs
diff --git a/src/toxcore/onion/packet/onion_request_0.rs b/src/toxcore/onion/packet/onion_request_0.rs
diff --git a/src/toxcore/onion/packet/onion_request_1.rs b/src/toxcore/onion/packet/onion_request_1.rs
diff --git a/src/toxcore/onion/packet/onion_request_2.rs b/src/toxcore/onion/packet/onion_request_2.rs
diff --git a/src/toxcore/onion/packet/onion_response_1.rs b/src/toxcore/onion/packet/onion_response_1.rs
diff --git a/src/toxcore/onion/packet/onion_response_2.rs b/src/toxcore/onion/packet/onion_response_2.rs
diff --git a/src/toxcore/onion/packet/onion_response_3.rs b/src/toxcore/onion/packet/onion_response_3.rs

Original file line number	Diff line number	Diff line change
`@@ -72,11 +72,6 @@ impl ToBytes for Ipv6Addr {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`-/// Parser that returns the length of the remaining input.`
`76`		`-pub fn rest_len(input: &[u8]) -> IResult<&[u8], usize> {`
`77`		`- Ok((input, input.len()))`
`78`		`-}`
`79`		`-`
`80`	`75`	`/// Generator that ensures that length of serialized data does not exceed specified limit.`
`81`	`76`	`pub fn gen_len_limit(buf: (&mut [u8], usize), limit: usize) -> Result<(&mut [u8], usize), GenError> {`
`82`	`77`	`if buf.1 <= limit {`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`use byteorder::{ByteOrder, BigEndian};`
`5`	`5`	`use nom::{number::complete::{be_u16, be_u32},`
`6`		`- combinator::rest,`
	`6`	`+ combinator::{rest, rest_len},`
`7`	`7`	`};`
`8`	`8`
`9`	`9`	`use crate::toxcore::binary_io::*;`
`@@ -236,6 +236,6 @@ mod tests {`
`236`	`236`	`};`
`237`	`237`	`let decoded_payload = invalid_packet.get_payload(&shared_secret, &nonce);`
`238`	`238`	`let error = decoded_payload.err().unwrap();`
`239`		`- assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize { error: Err::Error(("".to_owned(), ErrorKind::Eof)), payload: invalid_payload.to_vec() });`
	`239`	`+ assert_eq!(*error.kind(), GetPayloadErrorKind::Deserialize { error: Err::Error((vec![], ErrorKind::Eof)), payload: invalid_payload.to_vec() });`
`240`	`240`	`}`
`241`	`241`	`}`