vendor/github.com/multiformats/go-multihash/io_test.go

   1 package multihash
   2
   3 import (
   4         "bytes"
   5         "io"
   6         "testing"
   7 )
   8
   9 type evilReader struct {
  10         buffer []byte
  11 }
  12
  13 func (er *evilReader) Read(buf []byte) (int, error) {
  14         n := copy(buf, er.buffer)
  15         er.buffer = er.buffer[n:]
  16         var err error
  17         if len(er.buffer) == 0 {
  18                 err = io.EOF
  19         }
  20         return n, err
  21 }
  22
  23 func TestEvilReader(t *testing.T) {
  24         emptyHash, err := Sum(nil, ID, 0)
  25         if err != nil {
  26                 t.Fatal(err)
  27         }
  28         r := NewReader(&evilReader{emptyHash})
  29         h, err := r.ReadMultihash()
  30         if err != nil {
  31                 t.Fatal(err)
  32         }
  33         if !bytes.Equal(h, []byte(emptyHash)) {
  34                 t.Fatal(err)
  35         }
  36         h, err = r.ReadMultihash()
  37         if len([]byte(h)) > 0 || err != io.EOF {
  38                 t.Fatal("expected end of file")
  39         }
  40 }
  41
  42 func TestReader(t *testing.T) {
  43
  44         var buf bytes.Buffer
  45
  46         for _, tc := range testCases {
  47                 m, err := tc.Multihash()
  48                 if err != nil {
  49                         t.Fatal(err)
  50                 }
  51
  52                 buf.Write([]byte(m))
  53         }
  54
  55         r := NewReader(&buf)
  56
  57         for _, tc := range testCases {
  58                 h, err := tc.Multihash()
  59                 if err != nil {
  60                         t.Fatal(err)
  61                 }
  62
  63                 h2, err := r.ReadMultihash()
  64                 if err != nil {
  65                         t.Error(err)
  66                         continue
  67                 }
  68
  69                 if !bytes.Equal(h, h2) {
  70                         t.Error("h and h2 should be equal")
  71                 }
  72         }
  73 }
  74
  75 func TestWriter(t *testing.T) {
  76
  77         var buf bytes.Buffer
  78         w := NewWriter(&buf)
  79
  80         for _, tc := range testCases {
  81                 m, err := tc.Multihash()
  82                 if err != nil {
  83                         t.Error(err)
  84                         continue
  85                 }
  86
  87                 if err := w.WriteMultihash(m); err != nil {
  88                         t.Error(err)
  89                         continue
  90                 }
  91
  92                 buf2 := make([]byte, len(m))
  93                 if _, err := io.ReadFull(&buf, buf2); err != nil {
  94                         t.Error(err)
  95                         continue
  96                 }
  97
  98                 if !bytes.Equal(m, buf2) {
  99                         t.Error("m and buf2 should be equal")
 100                 }
 101         }
 102 }