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-2017 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 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, path)
  45                 if err != nil {
  46                         panic(err)
  47                 }
  48                 err = PktEncWrite(nodeOur, nodeTheir.Their(), pkt, 123, int64(size), dataR, &ct)
  49                 if err != nil {
  50                         return false
  51                 }
  52                 var pktEnc PktEnc
  53                 if _, err = xdr.Unmarshal(&ct, &pktEnc); err != nil {
  54                         return false
  55                 }
  56                 if *pktEnc.Sender != *nodeOur.Id {
  57                         return false
  58                 }
  59                 return true
  60         }
  61         if err := quick.Check(f, nil); err != nil {
  62                 t.Error(err)
  63         }
  64 }
  65
  66 func TestPktEncRead(t *testing.T) {
  67         node1, err := NewNodeGenerate()
  68         if err != nil {
  69                 panic(err)
  70         }
  71         node2, err := NewNodeGenerate()
  72         if err != nil {
  73                 panic(err)
  74         }
  75         f := func(path string, pathSize uint8, data [1 << 16]byte, size uint16, junk []byte) bool {
  76                 dataR := bytes.NewReader(data[:])
  77                 var ct bytes.Buffer
  78                 if len(path) > int(pathSize) {
  79                         path = path[:int(pathSize)]
  80                 }
  81                 pkt, err := NewPkt(PktTypeFile, path)
  82                 if err != nil {
  83                         panic(err)
  84                 }
  85                 err = PktEncWrite(node1, node2.Their(), pkt, 123, int64(size), dataR, &ct)
  86                 if err != nil {
  87                         return false
  88                 }
  89                 ct.Write(junk)
  90                 var pt bytes.Buffer
  91                 nodes := make(map[NodeId]*Node)
  92                 nodes[*node1.Id] = node1.Their()
  93                 node, err := PktEncRead(node2, nodes, &ct, &pt)
  94                 if err != nil {
  95                         return false
  96                 }
  97                 if *node.Id != *node1.Id {
  98                         return false
  99                 }
 100                 var pktBuf bytes.Buffer
 101                 xdr.Marshal(&pktBuf, &pkt)
 102                 return bytes.Compare(pt.Bytes(), append(pktBuf.Bytes(), data[:int(size)]...)) == 0
 103         }
 104         if err := quick.Check(f, nil); err != nil {
 105                 t.Error(err)
 106         }
 107 }