1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
12 use lightning::util::ser::Writer;
13 pub struct VecWriter(pub Vec<u8>);
14 impl Writer for VecWriter {
15 fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
16 self.0.extend_from_slice(buf);
21 // We attempt to test the strictest behavior we can for a given message, however, some messages
22 // have different expected behavior. You can see which messages have which behavior in
23 // gen_target.sh, but, in general, the *_announcement messages have to round-trip exactly (as
24 // otherwise we'd invalidate the signatures), most messages just need to round-trip up to the
25 // amount of data we know how to interpret, and some messages we may throw out invalid stuff (eg
26 // if an error message isn't valid UTF-8 we cant String-ize it), so they wont roundtrip correctly.
28 // Tests a message that must survive roundtrip exactly, though may not empty the read buffer
31 macro_rules! test_msg {
32 ($MsgType: path, $data: ident) => {{
33 use lightning::util::ser::{Readable, Writeable};
34 let mut r = ::std::io::Cursor::new($data);
35 if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
36 let p = r.position() as usize;
37 let mut w = VecWriter(Vec::new());
38 msg.write(&mut w).unwrap();
40 assert_eq!(w.0.len(), p);
41 assert_eq!(msg.serialized_length(), p);
42 assert_eq!(&r.into_inner()[..p], &w.0[..p]);
47 // Tests a message that may lose data on roundtrip, but shoulnd't lose data compared to our
50 macro_rules! test_msg_simple {
51 ($MsgType: path, $data: ident) => {{
52 use lightning::util::ser::{Readable, Writeable};
53 let mut r = ::std::io::Cursor::new($data);
54 if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
55 let mut w = VecWriter(Vec::new());
56 msg.write(&mut w).unwrap();
57 assert_eq!(msg.serialized_length(), w.0.len());
59 let msg = <$MsgType as Readable>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
60 let mut w_two = VecWriter(Vec::new());
61 msg.write(&mut w_two).unwrap();
62 assert_eq!(&w.0[..], &w_two.0[..]);
67 // Tests a message that must survive roundtrip exactly, and must exactly empty the read buffer and
68 // split it back out on re-serialization.
70 macro_rules! test_msg_exact {
71 ($MsgType: path, $data: ident) => {{
72 use lightning::util::ser::{Readable, Writeable};
73 let mut r = ::std::io::Cursor::new($data);
74 if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
75 let mut w = VecWriter(Vec::new());
76 msg.write(&mut w).unwrap();
77 assert_eq!(&r.into_inner()[..], &w.0[..]);
78 assert_eq!(msg.serialized_length(), w.0.len());
83 // Tests a message that must survive roundtrip exactly, modulo one "hole" which may be set to
84 // any value on re-serialization.
86 macro_rules! test_msg_hole {
87 ($MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => {{
88 use lightning::util::ser::{Readable, Writeable};
89 let mut r = ::std::io::Cursor::new($data);
90 if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
91 let mut w = VecWriter(Vec::new());
92 msg.write(&mut w).unwrap();
93 let p = w.0.len() as usize;
94 assert_eq!(msg.serialized_length(), p);
96 assert_eq!(w.0.len(), p);
97 assert_eq!(&r.get_ref()[..$hole], &w.0[..$hole]);
98 assert_eq!(&r.get_ref()[$hole + $hole_len..p], &w.0[$hole + $hole_len..]);