src/cypherpunks.ru/nncp/pkt_test.go

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