@@ -29,81 +29,73 @@ impl Writer for VecWriter {
2929// entirely
3030#[ macro_export]
3131macro_rules! test_msg {
32- ( $MsgType: path, $data: ident) => {
33- {
34- use lightning:: util:: ser:: { Writeable , Readable } ;
35- let mut r = :: std:: io:: Cursor :: new( $data) ;
36- if let Ok ( msg) = <$MsgType as Readable >:: read( & mut r) {
37- let p = r. position( ) as usize ;
38- let mut w = VecWriter ( Vec :: new( ) ) ;
39- msg. write( & mut w) . unwrap( ) ;
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( ) ;
4039
41- assert_eq!( w. 0 . len( ) , p) ;
42- assert_eq!( msg. serialized_length( ) , p) ;
43- assert_eq!( & r. into_inner( ) [ ..p] , & w. 0 [ ..p] ) ;
44- }
40+ assert_eq!( w. 0 . len( ) , p) ;
41+ assert_eq!( msg. serialized_length( ) , p) ;
42+ assert_eq!( & r. into_inner( ) [ ..p] , & w. 0 [ ..p] ) ;
4543 }
46- }
44+ } } ;
4745}
4846
4947// Tests a message that may lose data on roundtrip, but shoulnd't lose data compared to our
5048// re-serialization.
5149#[ macro_export]
5250macro_rules! test_msg_simple {
53- ( $MsgType: path, $data: ident) => {
54- {
55- use lightning:: util:: ser:: { Writeable , Readable } ;
56- let mut r = :: std:: io:: Cursor :: new( $data) ;
57- if let Ok ( msg) = <$MsgType as Readable >:: read( & mut r) {
58- let mut w = VecWriter ( Vec :: new( ) ) ;
59- msg. write( & mut w) . unwrap( ) ;
60- assert_eq!( msg. serialized_length( ) , w. 0 . len( ) ) ;
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( ) ) ;
6158
62- let msg = <$MsgType as Readable >:: read( & mut :: std:: io:: Cursor :: new( & w. 0 ) ) . unwrap( ) ;
63- let mut w_two = VecWriter ( Vec :: new( ) ) ;
64- msg. write( & mut w_two) . unwrap( ) ;
65- assert_eq!( & w. 0 [ ..] , & w_two. 0 [ ..] ) ;
66- }
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 [ ..] ) ;
6763 }
68- }
64+ } } ;
6965}
7066
7167// Tests a message that must survive roundtrip exactly, and must exactly empty the read buffer and
7268// split it back out on re-serialization.
7369#[ macro_export]
7470macro_rules! test_msg_exact {
75- ( $MsgType: path, $data: ident) => {
76- {
77- use lightning:: util:: ser:: { Writeable , Readable } ;
78- let mut r = :: std:: io:: Cursor :: new( $data) ;
79- if let Ok ( msg) = <$MsgType as Readable >:: read( & mut r) {
80- let mut w = VecWriter ( Vec :: new( ) ) ;
81- msg. write( & mut w) . unwrap( ) ;
82- assert_eq!( & r. into_inner( ) [ ..] , & w. 0 [ ..] ) ;
83- assert_eq!( msg. serialized_length( ) , w. 0 . len( ) ) ;
84- }
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( ) ) ;
8579 }
86- }
80+ } } ;
8781}
8882
8983// Tests a message that must survive roundtrip exactly, modulo one "hole" which may be set to
9084// any value on re-serialization.
9185#[ macro_export]
9286macro_rules! test_msg_hole {
93- ( $MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => {
94- {
95- use lightning:: util:: ser:: { Writeable , Readable } ;
96- let mut r = :: std:: io:: Cursor :: new( $data) ;
97- if let Ok ( msg) = <$MsgType as Readable >:: read( & mut r) {
98- let mut w = VecWriter ( Vec :: new( ) ) ;
99- msg. write( & mut w) . unwrap( ) ;
100- let p = w. 0 . len( ) as usize ;
101- assert_eq!( msg. serialized_length( ) , p) ;
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) ;
10295
103- assert_eq!( w. 0 . len( ) , p) ;
104- assert_eq!( & r. get_ref( ) [ ..$hole] , & w. 0 [ ..$hole] ) ;
105- assert_eq!( & r. get_ref( ) [ $hole+$hole_len..p] , & w. 0 [ $hole+$hole_len..] ) ;
106- }
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..] ) ;
10799 }
108- }
100+ } } ;
109101}
0 commit comments