Raise copyright years

[nncp.git] / src / pkt_test.go

diff --git a/src/pkt_test.go b/src/pkt_test.go
index 079acbd794622cc0763d5eb258846a47182b96f2..37cb637b9dfc2aeb9ec8e3be344d80a100a01f95 100644 (file)
--- a/src/pkt_test.go
+++ b/src/pkt_test.go
@@ -1,6 +1,6 @@
 /*
 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
-Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2016-2022 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
@@ -19,6 +19,8 @@ package nncp
 
 import (
        "bytes"
+       "crypto/rand"
+       "io"
        "testing"
        "testing/quick"
 
@@ -34,24 +36,37 @@ func TestPktEncWrite(t *testing.T) {
        if err != nil {
                panic(err)
        }
-       f := func(path string, pathSize uint8, data [1 << 16]byte, size, padSize uint16) bool {
-               dataR := bytes.NewReader(data[:])
+       f := func(
+               path string,
+               pathSize uint8,
+               dataSize uint32,
+               size, minSize uint16,
+               wrappers uint8,
+       ) bool {
+               dataSize %= 1 << 20
+               data := make([]byte, dataSize)
+               if _, err = io.ReadFull(rand.Reader, data); err != nil {
+                       panic(err)
+               }
                var ct bytes.Buffer
                if len(path) > int(pathSize) {
                        path = path[:int(pathSize)]
                }
-               pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
+               nice := uint8(123)
+               pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
                if err != nil {
                        panic(err)
                }
-               _, err = PktEncWrite(
+               wrappers %= 8
+               _, _, err = PktEncWrite(
                        nodeOur,
                        nodeTheir.Their(),
                        pkt,
-                       123,
-                       int64(size),
-                       int64(padSize),
-                       dataR,
+                       nice,
+                       int64(minSize),
+                       MaxFileSize,
+                       int(wrappers),
+                       bytes.NewReader(data),
                        &ct,
                )
                if err != nil {
@@ -83,48 +98,55 @@ func TestPktEncRead(t *testing.T) {
        f := func(
                path string,
                pathSize uint8,
-               data [1 << 16]byte,
-               size, padSize uint16,
-               junk []byte) bool {
-               dataR := bytes.NewReader(data[:])
+               dataSize uint32,
+               minSize uint16,
+               wrappers uint8,
+       ) bool {
+               dataSize %= 1 << 20
+               data := make([]byte, dataSize)
+               if _, err = io.ReadFull(rand.Reader, data); err != nil {
+                       panic(err)
+               }
                var ct bytes.Buffer
                if len(path) > int(pathSize) {
                        path = path[:int(pathSize)]
                }
-               pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
+               nice := uint8(123)
+               pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
                if err != nil {
                        panic(err)
                }
-               _, err = PktEncWrite(
+               wrappers %= 8
+               _, _, err = PktEncWrite(
                        node1,
                        node2.Their(),
                        pkt,
-                       123,
-                       int64(size),
-                       int64(padSize),
-                       dataR,
+                       nice,
+                       int64(minSize),
+                       MaxFileSize,
+                       int(wrappers),
+                       bytes.NewReader(data),
                        &ct,
                )
                if err != nil {
                        return false
                }
-               ct.Write(junk)
                var pt bytes.Buffer
                nodes := make(map[NodeId]*Node)
                nodes[*node1.Id] = node1.Their()
-               node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt)
+               _, node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt, true, nil)
                if err != nil {
                        return false
                }
                if *node.Id != *node1.Id {
                        return false
                }
-               if sizeGot != sizeWithTags(PktOverhead+int64(size)) {
+               if sizeGot != int64(len(data)+int(PktOverhead)) {
                        return false
                }
                var pktBuf bytes.Buffer
                xdr.Marshal(&pktBuf, &pkt)
-               return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data[:int(size)]...)) == 0
+               return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data...)) == 0
        }
        if err := quick.Check(f, nil); err != nil {
                t.Error(err)