ns_test.go

   1 // netstring -- netstring format serialization library
   2 // Copyright (C) 2015-2024 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, version 3 of the License.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 package netstring
  17
  18 import (
  19         "bytes"
  20         "io"
  21         "testing"
  22         "testing/quick"
  23 )
  24
  25 func TestTrivial(t *testing.T) {
  26         var buf bytes.Buffer
  27         w := NewWriter(&buf)
  28         if n, err := w.WriteChunk([]byte{}); err != nil || n != 3 || string(buf.Next(3)) != "0:," {
  29                 t.FailNow()
  30         }
  31         if n, err := w.WriteChunk([]byte("foo")); err != nil || n != 6 {
  32                 t.FailNow()
  33         }
  34         if n, err := w.WriteChunk([]byte("barz")); err != nil || n != 7 {
  35                 t.FailNow()
  36         }
  37         if buf.String() != "3:foo,4:barz," {
  38                 t.FailNow()
  39         }
  40         r := NewReader(&buf)
  41         if n, err := r.Next(); err != nil || n != 3 {
  42                 t.FailNow()
  43         }
  44         if r.Discard() != nil {
  45                 t.FailNow()
  46         }
  47         if n, err := r.Next(); err != nil || n != 4 {
  48                 t.FailNow()
  49         }
  50         m := make([]byte, 4)
  51         if n, err := r.Read(m); err != nil || n != 4 {
  52                 t.FailNow()
  53         }
  54         if !bytes.Equal(m, []byte("barz")) {
  55                 t.FailNow()
  56         }
  57 }
  58
  59 func TestSymmetric(t *testing.T) {
  60         var buf bytes.Buffer
  61         w := NewWriter(&buf)
  62         r := NewReader(&buf)
  63         f := func(datum [][]byte) bool {
  64                 for _, data := range datum {
  65                         if n, err := w.WriteChunk(data); err != nil || n <= len(data) {
  66                                 return false
  67                         }
  68                 }
  69                 for _, data := range datum {
  70                         if n, err := r.Next(); err != nil || n != uint64(len(data)) {
  71                                 return false
  72                         }
  73                         got, err := io.ReadAll(r)
  74                         if err != nil || !bytes.Equal(got, data) {
  75                                 return false
  76                         }
  77                 }
  78                 return true
  79         }
  80         if err := quick.Check(f, nil); err != nil {
  81                 t.Error(err)
  82         }
  83 }
  84
  85 func TestErrors(t *testing.T) {
  86         b := bytes.NewBufferString("junk")
  87         r := NewReader(b)
  88         if _, err := r.Next(); err == nil {
  89                 t.FailNow()
  90         }
  91
  92         b = bytes.NewBufferString("1111111111111111111111:")
  93         r = NewReader(b)
  94         if _, err := r.Next(); err == nil {
  95                 t.FailNow()
  96         }
  97
  98         b = bytes.NewBufferString("6foobar")
  99         r = NewReader(b)
 100         if _, err := r.Next(); err == nil {
 101                 t.FailNow()
 102         }
 103
 104         data := make([]byte, 1<<10)
 105
 106         b = bytes.NewBufferString("0:foobar,")
 107         r = NewReader(b)
 108         if _, err := r.Next(); err == nil {
 109                 t.FailNow()
 110         }
 111
 112         b = bytes.NewBufferString("6:foobar")
 113         r = NewReader(b)
 114         if _, err := r.Next(); err != nil {
 115                 t.FailNow()
 116         }
 117         if _, err := r.Read(data); err == nil {
 118                 t.FailNow()
 119         }
 120
 121         b = bytes.NewBufferString(":foobar,")
 122         r = NewReader(b)
 123         if _, err := r.Next(); err == nil {
 124                 t.FailNow()
 125         }
 126
 127         b = bytes.NewBufferString("06:foobar,")
 128         r = NewReader(b)
 129         if _, err := r.Next(); err == nil {
 130                 t.FailNow()
 131         }
 132 }
 133
 134 func TestExample(t *testing.T) {
 135         var b bytes.Buffer
 136         w := NewWriter(&b)
 137         if n, err := w.WriteChunk([]byte("hello")); err != nil || n != 8 || b.String() != "5:hello," {
 138                 t.FailNow()
 139         }
 140         if n, err := w.WriteSize(6); err != nil || n != 2 {
 141                 t.FailNow()
 142         }
 143         if n, err := w.Write([]byte("wor")); err != nil || n != 3 {
 144                 t.FailNow()
 145         }
 146         if n, err := w.Write([]byte("ld!")); err != nil || n != 3 || b.String() != "5:hello,6:world!," {
 147                 t.FailNow()
 148         }
 149         r := NewReader(&b)
 150         if size, err := r.Next(); err != nil || size != 5 {
 151                 t.FailNow()
 152         }
 153         if err := r.Discard(); err != nil {
 154                 t.FailNow()
 155         }
 156         if size, err := r.Next(); err != nil || size != 6 {
 157                 t.FailNow()
 158         }
 159         if data, err := io.ReadAll(r); err != nil || string(data) != "world!" {
 160                 t.FailNow()
 161         }
 162 }