src/pkt_test.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package nncp
  19
  20 import (
  21         "bytes"
  22         "testing"
  23         "testing/quick"
  24
  25         xdr "github.com/davecgh/go-xdr/xdr2"
  26 )
  27
  28 func TestPktEncWrite(t *testing.T) {
  29         nodeOur, err := NewNodeGenerate()
  30         if err != nil {
  31                 panic(err)
  32         }
  33         nodeTheir, err := NewNodeGenerate()
  34         if err != nil {
  35                 panic(err)
  36         }
  37         f := func(path string, pathSize uint8, data [1 << 16]byte, size, padSize uint16) bool {
  38                 dataR := bytes.NewReader(data[:])
  39                 var ct bytes.Buffer
  40                 if len(path) > int(pathSize) {
  41                         path = path[:int(pathSize)]
  42                 }
  43                 pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
  44                 if err != nil {
  45                         panic(err)
  46                 }
  47                 _, err = PktEncWrite(
  48                         nodeOur,
  49                         nodeTheir.Their(),
  50                         pkt,
  51                         123,
  52                         int64(size),
  53                         int64(padSize),
  54                         dataR,
  55                         &ct,
  56                 )
  57                 if err != nil {
  58                         return false
  59                 }
  60                 var pktEnc PktEnc
  61                 if _, err = xdr.Unmarshal(&ct, &pktEnc); err != nil {
  62                         return false
  63                 }
  64                 if *pktEnc.Sender != *nodeOur.Id {
  65                         return false
  66                 }
  67                 return true
  68         }
  69         if err := quick.Check(f, nil); err != nil {
  70                 t.Error(err)
  71         }
  72 }
  73
  74 func TestPktEncRead(t *testing.T) {
  75         node1, err := NewNodeGenerate()
  76         if err != nil {
  77                 panic(err)
  78         }
  79         node2, err := NewNodeGenerate()
  80         if err != nil {
  81                 panic(err)
  82         }
  83         f := func(
  84                 path string,
  85                 pathSize uint8,
  86                 data [1 << 16]byte,
  87                 size, padSize uint16,
  88                 junk []byte) bool {
  89                 dataR := bytes.NewReader(data[:])
  90                 var ct bytes.Buffer
  91                 if len(path) > int(pathSize) {
  92                         path = path[:int(pathSize)]
  93                 }
  94                 pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
  95                 if err != nil {
  96                         panic(err)
  97                 }
  98                 _, err = PktEncWrite(
  99                         node1,
 100                         node2.Their(),
 101                         pkt,
 102                         123,
 103                         int64(size),
 104                         int64(padSize),
 105                         dataR,
 106                         &ct,
 107                 )
 108                 if err != nil {
 109                         return false
 110                 }
 111                 ct.Write(junk)
 112                 var pt bytes.Buffer
 113                 nodes := make(map[NodeId]*Node)
 114                 nodes[*node1.Id] = node1.Their()
 115                 _, node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt, true, nil)
 116                 if err != nil {
 117                         return false
 118                 }
 119                 if *node.Id != *node1.Id {
 120                         return false
 121                 }
 122                 if sizeGot != sizeWithTags(PktOverhead+int64(size)) {
 123                         return false
 124                 }
 125                 var pktBuf bytes.Buffer
 126                 xdr.Marshal(&pktBuf, &pkt)
 127                 return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data[:int(size)]...)) == 0
 128         }
 129         if err := quick.Check(f, nil); err != nil {
 130                 t.Error(err)
 131         }
 132 }