Forbid any later GNU GPL versions autousage

[nncp.git] / src / cypherpunks.ru / nncp / pkt_test.go

diff --git a/src/cypherpunks.ru/nncp/pkt_test.go b/src/cypherpunks.ru/nncp/pkt_test.go
index 95d765e228980e06121d665136d76e6151458792..678cbf474a420fba1d7c9aa1becee2822ad17389 100644 (file)
--- a/src/cypherpunks.ru/nncp/pkt_test.go
+++ b/src/cypherpunks.ru/nncp/pkt_test.go
@@ -1,11 +1,10 @@
 /*
-NNCP -- Node-to-Node CoPy
-Copyright (C) 2016-2017 Sergey Matveev <stargrave@stargrave.org>
+NNCP -- Node to Node copy, utilities for store-and-forward data exchange
+Copyright (C) 2016-2019 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+the Free Software Foundation, version 3 of the License.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -35,17 +34,26 @@ func TestPktEncWrite(t *testing.T) {
        if err != nil {
                panic(err)
        }
-       f := func(path string, pathSize uint8, data [1 << 16]byte, size uint16) bool {
+       f := func(path string, pathSize uint8, data [1 << 16]byte, size, padSize uint16) bool {
                dataR := bytes.NewReader(data[:])
                var ct bytes.Buffer
                if len(path) > int(pathSize) {
                        path = path[:int(pathSize)]
                }
-               pkt, err := NewPkt(PktTypeFile, path)
+               pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
                if err != nil {
                        panic(err)
                }
-               err = PktEncWrite(nodeOur, nodeTheir.Their(), pkt, 123, int64(size), dataR, &ct)
+               err = PktEncWrite(
+                       nodeOur,
+                       nodeTheir.Their(),
+                       pkt,
+                       123,
+                       int64(size),
+                       int64(padSize),
+                       dataR,
+                       &ct,
+               )
                if err != nil {
                        return false
                }
@@ -56,9 +64,6 @@ func TestPktEncWrite(t *testing.T) {
                if *pktEnc.Sender != *nodeOur.Id {
                        return false
                }
-               if pktEnc.Size != uint64(ct.Len()) {
-                       return false
-               }
                return true
        }
        if err := quick.Check(f, nil); err != nil {
@@ -75,30 +80,48 @@ func TestPktEncRead(t *testing.T) {
        if err != nil {
                panic(err)
        }
-       f := func(path string, pathSize uint8, data [1 << 16]byte, size uint16) bool {
+       f := func(
+               path string,
+               pathSize uint8,
+               data [1 << 16]byte,
+               size, padSize uint16,
+               junk []byte) bool {
                dataR := bytes.NewReader(data[:])
                var ct bytes.Buffer
                if len(path) > int(pathSize) {
                        path = path[:int(pathSize)]
                }
-               pkt, err := NewPkt(PktTypeFile, path)
+               pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
                if err != nil {
                        panic(err)
                }
-               err = PktEncWrite(node1, node2.Their(), pkt, 123, int64(size), dataR, &ct)
+               err = PktEncWrite(
+                       node1,
+                       node2.Their(),
+                       pkt,
+                       123,
+                       int64(size),
+                       int64(padSize),
+                       dataR,
+                       &ct,
+               )
                if err != nil {
                        return false
                }
+               ct.Write(junk)
                var pt bytes.Buffer
                nodes := make(map[NodeId]*Node)
                nodes[*node1.Id] = node1.Their()
-               node, err := PktEncRead(node2, nodes, &ct, &pt)
+               node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt)
                if err != nil {
                        return false
                }
                if *node.Id != *node1.Id {
                        return false
                }
+               if sizeGot != sizeWithTags(PktOverhead+int64(size)) {
+                       return false
+               }
                var pktBuf bytes.Buffer
                xdr.Marshal(&pktBuf, &pkt)
                return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data[:int(size)]...)) == 0