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-2018 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(path string, pathSize uint8, data [1 << 16]byte, size, padSize uint16, junk []byte) bool {
  85                 dataR := bytes.NewReader(data[:])
  86                 var ct bytes.Buffer
  87                 if len(path) > int(pathSize) {
  88                         path = path[:int(pathSize)]
  89                 }
  90                 pkt, err := NewPkt(PktTypeFile, 123, []byte(path))
  91                 if err != nil {
  92                         panic(err)
  93                 }
  94                 err = PktEncWrite(
  95                         node1,
  96                         node2.Their(),
  97                         pkt,
  98                         123,
  99                         int64(size),
 100                         int64(padSize),
 101                         dataR,
 102                         &ct,
 103                 )
 104                 if err != nil {
 105                         return false
 106                 }
 107                 ct.Write(junk)
 108                 var pt bytes.Buffer
 109                 nodes := make(map[NodeId]*Node)
 110                 nodes[*node1.Id] = node1.Their()
 111                 node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt)
 112                 if err != nil {
 113                         return false
 114                 }
 115                 if *node.Id != *node1.Id {
 116                         return false
 117                 }
 118                 if sizeGot != int64(size) {
 119                         return false
 120                 }
 121                 var pktBuf bytes.Buffer
 122                 xdr.Marshal(&pktBuf, &pkt)
 123                 return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data[:int(size)]...)) == 0
 124         }
 125         if err := quick.Check(f, nil); err != nil {
 126                 t.Error(err)
 127         }
 128 }