netstring_test.go

   1 /*
   2 netstring -- netstring format serialization library
   3 Copyright (C) 2015-2020 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 netstring
  19
  20 import (
  21         "bytes"
  22         "testing"
  23         "testing/quick"
  24 )
  25
  26 func TestTrivial(t *testing.T) {
  27         buf := bytes.NewBuffer(nil)
  28         w := NewWriter(buf)
  29         if n, err := w.Write([]byte{}); err != nil || n != 3 || string(buf.Next(3)) != "0:," {
  30                 t.Fail()
  31         }
  32         if n, err := w.Write([]byte("foo")); err != nil || n != 6 {
  33                 t.Fail()
  34         }
  35         if n, err := w.Write([]byte("barz")); err != nil || n != 7 {
  36                 t.Fail()
  37         }
  38         if string(buf.Bytes()) != "3:foo,4:barz," {
  39                 t.Fail()
  40         }
  41         r := NewReader(buf)
  42         if n, err := r.Iter(); err != nil || n != 3 {
  43                 t.Fail()
  44         }
  45         if r.Discard() != nil {
  46                 t.Fail()
  47         }
  48         if n, err := r.Iter(); err != nil || n != 4 {
  49                 t.Fail()
  50         }
  51         m := make([]byte, int(4))
  52         if r.Read(m) != nil {
  53                 t.Fail()
  54         }
  55         if bytes.Compare(m, []byte("barz")) != 0 {
  56                 t.Fail()
  57         }
  58 }
  59
  60 func TestSymmetric(t *testing.T) {
  61         buf := bytes.NewBuffer(nil)
  62         w := NewWriter(buf)
  63         r := NewReader(buf)
  64         f := func(i uint8, data []byte) bool {
  65                 var n uint8
  66                 for n = 0; n < i; n++ {
  67                         if _, err := w.Write(data); err != nil {
  68                                 return false
  69                         }
  70                 }
  71                 for n = 0; n < i; n++ {
  72                         size, err := r.Iter()
  73                         if err != nil || int(size) != len(data) {
  74                                 return false
  75                         }
  76                         read := make([]byte, size)
  77                         if r.Read(read) != nil {
  78                                 return false
  79                         }
  80                         if bytes.Compare(read, data) != 0 {
  81                                 return false
  82                         }
  83                 }
  84                 return true
  85         }
  86         if err := quick.Check(f, nil); err != nil {
  87                 t.Error(err)
  88         }
  89 }
  90
  91 func TestErrors(t *testing.T) {
  92         b := bytes.NewBufferString("junk")
  93         r := NewReader(b)
  94         if _, err := r.Iter(); err == nil {
  95                 t.FailNow()
  96         }
  97
  98         b = bytes.NewBufferString("1111111111111111111111:")
  99         r = NewReader(b)
 100         if _, err := r.Iter(); err == nil {
 101                 t.FailNow()
 102         }
 103
 104         b = bytes.NewBufferString("6foobar")
 105         r = NewReader(b)
 106         if _, err := r.Iter(); err == nil {
 107                 t.FailNow()
 108         }
 109
 110         data := make([]byte, 1<<10)
 111
 112         b = bytes.NewBufferString("0:foobar,")
 113         r = NewReader(b)
 114         if _, err := r.Iter(); err != nil {
 115                 t.FailNow()
 116         }
 117         if r.Read(data) == nil {
 118                 t.FailNow()
 119         }
 120
 121         b = bytes.NewBufferString("0:foobar")
 122         r = NewReader(b)
 123         if _, err := r.Iter(); err != nil {
 124                 t.FailNow()
 125         }
 126         if r.Read(data) == nil {
 127                 t.FailNow()
 128         }
 129
 130         b = bytes.NewBufferString("6:foobar")
 131         r = NewReader(b)
 132         if _, err := r.Iter(); err != nil {
 133                 t.FailNow()
 134         }
 135         if r.Read(data) == nil {
 136                 t.FailNow()
 137         }
 138
 139 }