You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
106 lines
2.7 KiB
106 lines
2.7 KiB
package lnwire |
|
|
|
import ( |
|
"bytes" |
|
"encoding/hex" |
|
"reflect" |
|
"testing" |
|
|
|
"github.com/davecgh/go-spew/spew" |
|
) |
|
|
|
// TestReplyChannelRangeUnsorted tests that decoding a ReplyChannelRange request |
|
// that contains duplicate or unsorted ids returns an ErrUnsortedSIDs failure. |
|
func TestReplyChannelRangeUnsorted(t *testing.T) { |
|
for _, test := range unsortedSidTests { |
|
test := test |
|
t.Run(test.name, func(t *testing.T) { |
|
req := &ReplyChannelRange{ |
|
EncodingType: test.encType, |
|
ShortChanIDs: test.sids, |
|
noSort: true, |
|
} |
|
|
|
var b bytes.Buffer |
|
err := req.Encode(&b, 0) |
|
if err != nil { |
|
t.Fatalf("unable to encode req: %v", err) |
|
} |
|
|
|
var req2 ReplyChannelRange |
|
err = req2.Decode(bytes.NewReader(b.Bytes()), 0) |
|
if _, ok := err.(ErrUnsortedSIDs); !ok { |
|
t.Fatalf("expected ErrUnsortedSIDs, got: %v", |
|
err) |
|
} |
|
}) |
|
} |
|
} |
|
|
|
// TestReplyChannelRangeEmpty tests encoding and decoding a ReplyChannelRange |
|
// that doesn't contain any channel results. |
|
func TestReplyChannelRangeEmpty(t *testing.T) { |
|
t.Parallel() |
|
|
|
emptyChannelsTests := []struct { |
|
name string |
|
encType ShortChanIDEncoding |
|
encodedHex string |
|
}{ |
|
{ |
|
name: "empty plain encoding", |
|
encType: EncodingSortedPlain, |
|
encodedHex: "000000000000000000000000000000000000000" + |
|
"00000000000000000000000000000000100000002" + |
|
"01000100", |
|
}, |
|
{ |
|
name: "empty zlib encoding", |
|
encType: EncodingSortedZlib, |
|
encodedHex: "00000000000000000000000000000000000000" + |
|
"0000000000000000000000000000000001000000" + |
|
"0201000101", |
|
}, |
|
} |
|
|
|
for _, test := range emptyChannelsTests { |
|
test := test |
|
t.Run(test.name, func(t *testing.T) { |
|
req := ReplyChannelRange{ |
|
FirstBlockHeight: 1, |
|
NumBlocks: 2, |
|
Complete: 1, |
|
EncodingType: test.encType, |
|
ShortChanIDs: nil, |
|
ExtraData: make([]byte, 0), |
|
} |
|
|
|
// First decode the hex string in the test case into a |
|
// new ReplyChannelRange message. It should be |
|
// identical to the one created above. |
|
var req2 ReplyChannelRange |
|
b, _ := hex.DecodeString(test.encodedHex) |
|
err := req2.Decode(bytes.NewReader(b), 0) |
|
if err != nil { |
|
t.Fatalf("unable to decode req: %v", err) |
|
} |
|
if !reflect.DeepEqual(req, req2) { |
|
t.Fatalf("requests don't match: expected %v got %v", |
|
spew.Sdump(req), spew.Sdump(req2)) |
|
} |
|
|
|
// Next, we go in the reverse direction: encode the |
|
// request created above, and assert that it matches |
|
// the raw byte encoding. |
|
var b2 bytes.Buffer |
|
err = req.Encode(&b2, 0) |
|
if err != nil { |
|
t.Fatalf("unable to encode req: %v", err) |
|
} |
|
if !bytes.Equal(b, b2.Bytes()) { |
|
t.Fatalf("encoded requests don't match: expected %x got %x", |
|
b, b2.Bytes()) |
|
} |
|
}) |
|
} |
|
}
|
|
|