// TestAlert tests the MsgAlert API. func TestAlert(t *testing.T) { pver := btcwire.ProtocolVersion payloadblob := "some message" signature := "some sig" // Ensure we get the same payload and signature back out. msg := btcwire.NewMsgAlert(payloadblob, signature) if msg.PayloadBlob != payloadblob { t.Errorf("NewMsgAlert: wrong payloadblob - got %v, want %v", msg.PayloadBlob, payloadblob) } if msg.Signature != signature { t.Errorf("NewMsgAlert: wrong signature - got %v, want %v", msg.Signature, signature) } // Ensure the command is expected value. wantCmd := "alert" if cmd := msg.Command(); cmd != wantCmd { t.Errorf("NewMsgAlert: wrong command - got %v want %v", cmd, wantCmd) } // Ensure max payload is expected value. wantPayload := uint32(1024 * 1024 * 32) maxPayload := msg.MaxPayloadLength(pver) if maxPayload != wantPayload { t.Errorf("MaxPayloadLength: wrong max payload length for "+ "protocol version %d - got %v, want %v", pver, maxPayload, wantPayload) } return }
// TestAlertWire tests the MsgAlert wire encode and decode for various protocol // versions. func TestAlertWire(t *testing.T) { baseAlert := btcwire.NewMsgAlert("some payload", "somesig") baseAlertEncoded := []byte{ 0x0c, // Varint for payload length 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, // "some payload" 0x07, // Varint for signature length 0x73, 0x6f, 0x6d, 0x65, 0x73, 0x69, 0x67, // "somesig" } tests := []struct { in *btcwire.MsgAlert // Message to encode out *btcwire.MsgAlert // Expected decoded message buf []byte // Wire encoding pver uint32 // Protocol version for wire encoding }{ // Latest protocol version. { baseAlert, baseAlert, baseAlertEncoded, btcwire.ProtocolVersion, }, // Protocol version BIP0035Version. { baseAlert, baseAlert, baseAlertEncoded, btcwire.BIP0035Version, }, // Protocol version BIP0031Version. { baseAlert, baseAlert, baseAlertEncoded, btcwire.BIP0031Version, }, // Protocol version NetAddressTimeVersion. { baseAlert, baseAlert, baseAlertEncoded, btcwire.NetAddressTimeVersion, }, // Protocol version MultipleAddressVersion. { baseAlert, baseAlert, baseAlertEncoded, btcwire.MultipleAddressVersion, }, } t.Logf("Running %d tests", len(tests)) for i, test := range tests { // Encode the message to wire format. var buf bytes.Buffer err := test.in.BtcEncode(&buf, test.pver) if err != nil { t.Errorf("BtcEncode #%d error %v", i, err) continue } if !bytes.Equal(buf.Bytes(), test.buf) { t.Errorf("BtcEncode #%d\n got: %s want: %s", i, spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) continue } // Decode the message from wire format. var msg btcwire.MsgAlert rbuf := bytes.NewBuffer(test.buf) err = msg.BtcDecode(rbuf, test.pver) if err != nil { t.Errorf("BtcDecode #%d error %v", i, err) continue } if !reflect.DeepEqual(&msg, test.out) { t.Errorf("BtcDecode #%d\n got: %s want: %s", i, spew.Sdump(msg), spew.Sdump(test.out)) continue } } }
// TestAlertWireErrors performs negative tests against wire encode and decode // of MsgAlert to confirm error paths work correctly. func TestAlertWireErrors(t *testing.T) { pver := btcwire.ProtocolVersion baseAlert := btcwire.NewMsgAlert("some payload", "somesig") baseAlertEncoded := []byte{ 0x0c, // Varint for payload length 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, // "some payload" 0x07, // Varint for signature length 0x73, 0x6f, 0x6d, 0x65, 0x73, 0x69, 0x67, // "somesig" } tests := []struct { in *btcwire.MsgAlert // Value to encode buf []byte // Wire encoding pver uint32 // Protocol version for wire encoding max int // Max size of fixed buffer to induce errors writeErr error // Expected write error readErr error // Expected read error }{ // Force error in payload length. {baseAlert, baseAlertEncoded, pver, 0, io.ErrShortWrite, io.EOF}, // Force error in payload. {baseAlert, baseAlertEncoded, pver, 1, io.ErrShortWrite, io.EOF}, // Force error in signature length. {baseAlert, baseAlertEncoded, pver, 13, io.ErrShortWrite, io.EOF}, // Force error in signature. {baseAlert, baseAlertEncoded, pver, 14, io.ErrShortWrite, io.EOF}, } t.Logf("Running %d tests", len(tests)) for i, test := range tests { // Encode to wire format. w := newFixedWriter(test.max) err := test.in.BtcEncode(w, test.pver) if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) { t.Errorf("BtcEncode #%d wrong error got: %v, want: %v", i, err, test.writeErr) continue } // For errors which are not of type btcwire.MessageError, check // them for equality. if _, ok := err.(*btcwire.MessageError); !ok { if err != test.writeErr { t.Errorf("BtcEncode #%d wrong error got: %v, "+ "want: %v", i, err, test.writeErr) continue } } // Decode from wire format. var msg btcwire.MsgAlert r := newFixedReader(test.max, test.buf) err = msg.BtcDecode(r, test.pver) if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) { t.Errorf("BtcDecode #%d wrong error got: %v, want: %v", i, err, test.readErr) continue } // For errors which are not of type btcwire.MessageError, check // them for equality. if _, ok := err.(*btcwire.MessageError); !ok { if err != test.readErr { t.Errorf("BtcDecode #%d wrong error got: %v, "+ "want: %v", i, err, test.readErr) continue } } } }
// TestMessage tests the Read/WriteMessage API. func TestMessage(t *testing.T) { pver := btcwire.ProtocolVersion // Create the various types of messages to test. // MsgVersion. addrYou := &net.TCPAddr{IP: net.ParseIP("192.168.0.1"), Port: 8333} you, err := btcwire.NewNetAddress(addrYou, btcwire.SFNodeNetwork) if err != nil { t.Errorf("NewNetAddress: %v", err) } you.Timestamp = time.Time{} // Version message has zero value timestamp. addrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333} me, err := btcwire.NewNetAddress(addrMe, btcwire.SFNodeNetwork) if err != nil { t.Errorf("NewNetAddress: %v", err) } me.Timestamp = time.Time{} // Version message has zero value timestamp. msgVersion := btcwire.NewMsgVersion(me, you, 123123, "/test:0.0.1/", 0) msgVerack := btcwire.NewMsgVerAck() msgGetAddr := btcwire.NewMsgGetAddr() msgAddr := btcwire.NewMsgAddr() msgGetBlocks := btcwire.NewMsgGetBlocks(&btcwire.ShaHash{}) msgBlock := &blockOne msgInv := btcwire.NewMsgInv() msgGetData := btcwire.NewMsgGetData() msgNotFound := btcwire.NewMsgNotFound() msgTx := btcwire.NewMsgTx() msgPing := btcwire.NewMsgPing(123123) msgPong := btcwire.NewMsgPong(123123) msgGetHeaders := btcwire.NewMsgGetHeaders() msgHeaders := btcwire.NewMsgHeaders() msgAlert := btcwire.NewMsgAlert("payload", "signature") msgMemPool := btcwire.NewMsgMemPool() tests := []struct { in btcwire.Message // Value to encode out btcwire.Message // Expected decoded value pver uint32 // Protocol version for wire encoding btcnet btcwire.BitcoinNet // Network to use for wire encoding }{ {msgVersion, msgVersion, pver, btcwire.MainNet}, {msgVerack, msgVerack, pver, btcwire.MainNet}, {msgGetAddr, msgGetAddr, pver, btcwire.MainNet}, {msgAddr, msgAddr, pver, btcwire.MainNet}, {msgGetBlocks, msgGetBlocks, pver, btcwire.MainNet}, {msgBlock, msgBlock, pver, btcwire.MainNet}, {msgInv, msgInv, pver, btcwire.MainNet}, {msgGetData, msgGetData, pver, btcwire.MainNet}, {msgNotFound, msgNotFound, pver, btcwire.MainNet}, {msgTx, msgTx, pver, btcwire.MainNet}, {msgPing, msgPing, pver, btcwire.MainNet}, {msgPong, msgPong, pver, btcwire.MainNet}, {msgGetHeaders, msgGetHeaders, pver, btcwire.MainNet}, {msgHeaders, msgHeaders, pver, btcwire.MainNet}, {msgAlert, msgAlert, pver, btcwire.MainNet}, {msgMemPool, msgMemPool, pver, btcwire.MainNet}, } t.Logf("Running %d tests", len(tests)) for i, test := range tests { // Encode to wire format. var buf bytes.Buffer err := btcwire.WriteMessage(&buf, test.in, test.pver, test.btcnet) if err != nil { t.Errorf("WriteMessage #%d error %v", i, err) continue } // Decode from wire format. rbuf := bytes.NewBuffer(buf.Bytes()) msg, _, err := btcwire.ReadMessage(rbuf, test.pver, test.btcnet) if err != nil { t.Errorf("ReadMessage #%d error %v, msg %v", i, err, spew.Sdump(msg)) continue } if !reflect.DeepEqual(msg, test.out) { t.Errorf("ReadMessage #%d\n got: %v want: %v", i, spew.Sdump(msg), spew.Sdump(test.out)) continue } } }
// TestMsgAlertWireErrors performs negative tests against wire encode and decode // of MsgAlert to confirm error paths work correctly. func TestMsgAlertWireErrors(t *testing.T) { pver := btcwire.ProtocolVersion baseMsgAlert := btcwire.NewMsgAlert([]byte("some payload"), []byte("somesig")) baseMsgAlertEncoded := []byte{ 0x0c, // Varint for payload length 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, // "some payload" 0x07, // Varint for signature length 0x73, 0x6f, 0x6d, 0x65, 0x73, 0x69, 0x67, // "somesig" } tests := []struct { in *btcwire.MsgAlert // Value to encode buf []byte // Wire encoding pver uint32 // Protocol version for wire encoding max int // Max size of fixed buffer to induce errors writeErr error // Expected write error readErr error // Expected read error }{ // Force error in payload length. {baseMsgAlert, baseMsgAlertEncoded, pver, 0, io.ErrShortWrite, io.EOF}, // Force error in payload. {baseMsgAlert, baseMsgAlertEncoded, pver, 1, io.ErrShortWrite, io.EOF}, // Force error in signature length. {baseMsgAlert, baseMsgAlertEncoded, pver, 13, io.ErrShortWrite, io.EOF}, // Force error in signature. {baseMsgAlert, baseMsgAlertEncoded, pver, 14, io.ErrShortWrite, io.EOF}, } t.Logf("Running %d tests", len(tests)) for i, test := range tests { // Encode to wire format. w := newFixedWriter(test.max) err := test.in.BtcEncode(w, test.pver) if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) { t.Errorf("BtcEncode #%d wrong error got: %v, want: %v", i, err, test.writeErr) continue } // For errors which are not of type btcwire.MessageError, check // them for equality. if _, ok := err.(*btcwire.MessageError); !ok { if err != test.writeErr { t.Errorf("BtcEncode #%d wrong error got: %v, "+ "want: %v", i, err, test.writeErr) continue } } // Decode from wire format. var msg btcwire.MsgAlert r := newFixedReader(test.max, test.buf) err = msg.BtcDecode(r, test.pver) if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) { t.Errorf("BtcDecode #%d wrong error got: %v, want: %v", i, err, test.readErr) continue } // For errors which are not of type btcwire.MessageError, check // them for equality. if _, ok := err.(*btcwire.MessageError); !ok { if err != test.readErr { t.Errorf("BtcDecode #%d wrong error got: %v, "+ "want: %v", i, err, test.readErr) continue } } } // Test Error on empty Payload baseMsgAlert.SerializedPayload = []byte{} w := new(bytes.Buffer) err := baseMsgAlert.BtcEncode(w, pver) if _, ok := err.(*btcwire.MessageError); !ok { t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T", err, btcwire.MessageError{}) } // Test Payload Serialize error // overflow the max number of elements in SetCancel baseMsgAlert.Payload = new(btcwire.Alert) baseMsgAlert.Payload.SetCancel = make([]int32, btcwire.MaxCountSetCancel+1) buf := *new(bytes.Buffer) err = baseMsgAlert.BtcEncode(&buf, pver) if _, ok := err.(*btcwire.MessageError); !ok { t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T", err, btcwire.MessageError{}) } // overflow the max number of elements in SetSubVer baseMsgAlert.Payload = new(btcwire.Alert) baseMsgAlert.Payload.SetSubVer = make([]string, btcwire.MaxCountSetSubVer+1) buf = *new(bytes.Buffer) err = baseMsgAlert.BtcEncode(&buf, pver) if _, ok := err.(*btcwire.MessageError); !ok { t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T", err, btcwire.MessageError{}) } }
// TestMsgAlert tests the MsgAlert API. func TestMsgAlert(t *testing.T) { pver := btcwire.ProtocolVersion serializedpayload := []byte("some message") signature := []byte("some sig") // Ensure we get the same payload and signature back out. msg := btcwire.NewMsgAlert(serializedpayload, signature) if !reflect.DeepEqual(msg.SerializedPayload, serializedpayload) { t.Errorf("NewMsgAlert: wrong serializedpayload - got %v, want %v", msg.SerializedPayload, serializedpayload) } if !reflect.DeepEqual(msg.Signature, signature) { t.Errorf("NewMsgAlert: wrong signature - got %v, want %v", msg.Signature, signature) } // Ensure the command is expected value. wantCmd := "alert" if cmd := msg.Command(); cmd != wantCmd { t.Errorf("NewMsgAlert: wrong command - got %v want %v", cmd, wantCmd) } // Ensure max payload is expected value. wantPayload := uint32(1024 * 1024 * 32) maxPayload := msg.MaxPayloadLength(pver) if maxPayload != wantPayload { t.Errorf("MaxPayloadLength: wrong max payload length for "+ "protocol version %d - got %v, want %v", pver, maxPayload, wantPayload) } // Test BtcEncode with Payload == nil var buf bytes.Buffer err := msg.BtcEncode(&buf, pver) if err != nil { t.Error(err.Error()) } // expected = 0x0c + serializedpayload + 0x08 + signature expectedBuf := append([]byte{0x0c}, serializedpayload...) expectedBuf = append(expectedBuf, []byte{0x08}...) expectedBuf = append(expectedBuf, signature...) if !bytes.Equal(buf.Bytes(), expectedBuf) { t.Errorf("BtcEncode got: %s want: %s", spew.Sdump(buf.Bytes()), spew.Sdump(expectedBuf)) } // Test BtcEncode with Payload != nil // note: Payload is an empty Alert but not nil msg.Payload = new(btcwire.Alert) buf = *new(bytes.Buffer) err = msg.BtcEncode(&buf, pver) if err != nil { t.Error(err.Error()) } // empty Alert is 45 null bytes, see Alert comments // for details // expected = 0x2d + 45*0x00 + 0x08 + signature expectedBuf = append([]byte{0x2d}, bytes.Repeat([]byte{0x00}, 45)...) expectedBuf = append(expectedBuf, []byte{0x08}...) expectedBuf = append(expectedBuf, signature...) if !bytes.Equal(buf.Bytes(), expectedBuf) { t.Errorf("BtcEncode got: %s want: %s", spew.Sdump(buf.Bytes()), spew.Sdump(expectedBuf)) } }