@@ -29,81 +29,73 @@ impl Writer for VecWriter {
29
29
// entirely
30
30
#[ macro_export]
31
31
macro_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( ) ;
40
39
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] ) ;
45
43
}
46
- }
44
+ } } ;
47
45
}
48
46
49
47
// Tests a message that may lose data on roundtrip, but shoulnd't lose data compared to our
50
48
// re-serialization.
51
49
#[ macro_export]
52
50
macro_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( ) ) ;
61
58
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 [ ..] ) ;
67
63
}
68
- }
64
+ } } ;
69
65
}
70
66
71
67
// Tests a message that must survive roundtrip exactly, and must exactly empty the read buffer and
72
68
// split it back out on re-serialization.
73
69
#[ macro_export]
74
70
macro_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( ) ) ;
85
79
}
86
- }
80
+ } } ;
87
81
}
88
82
89
83
// Tests a message that must survive roundtrip exactly, modulo one "hole" which may be set to
90
84
// any value on re-serialization.
91
85
#[ macro_export]
92
86
macro_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) ;
102
95
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..] ) ;
107
99
}
108
- }
100
+ } } ;
109
101
}
0 commit comments