netstring_test.go

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