mse/mse_test.go

   1 package mse
   2
   3 import (
   4         "bytes"
   5         "io"
   6         "log"
   7         "net"
   8         "sync"
   9
  10         "testing"
  11 )
  12
  13 func TestReadUntil(t *testing.T) {
  14         test := func(data, until string, leftover int, expectedErr error) {
  15                 r := bytes.NewReader([]byte(data))
  16                 err := readUntil(r, []byte(until))
  17                 if err != expectedErr {
  18                         t.Fatal(err)
  19                 }
  20                 if r.Len() != leftover {
  21                         t.Fatal(r.Len())
  22                 }
  23         }
  24         test("feakjfeafeafegbaabc00", "abc", 2, nil)
  25         test("feakjfeafeafegbaadc00", "abc", 0, io.EOF)
  26 }
  27
  28 func TestSuffixMatchLen(t *testing.T) {
  29         test := func(a, b string, expected int) {
  30                 actual := suffixMatchLen([]byte(a), []byte(b))
  31                 if actual != expected {
  32                         t.Fatalf("expected %d, got %d for %q and %q", expected, actual, a, b)
  33                 }
  34         }
  35         test("hello", "world", 0)
  36         test("hello", "lo", 2)
  37         test("hello", "llo", 3)
  38         test("hello", "hell", 0)
  39         test("hello", "helloooo!", 5)
  40         test("hello", "lol!", 2)
  41         test("hello", "mondo", 0)
  42         test("mongo", "webscale", 0)
  43         test("sup", "person", 1)
  44 }
  45
  46 func TestHandshake(t *testing.T) {
  47         a, b := net.Pipe()
  48         wg := sync.WaitGroup{}
  49         wg.Add(2)
  50         go func() {
  51                 defer wg.Done()
  52                 a, err := Handshake(a, true, []byte("yep"))
  53                 if err != nil {
  54                         t.Fatal(err)
  55                         return
  56                 }
  57                 a.Write([]byte("hello world"))
  58                 var msg [20]byte
  59                 n, _ := a.Read(msg[:])
  60                 log.Print(string(msg[:n]))
  61         }()
  62         go func() {
  63                 defer wg.Done()
  64                 b, err := Handshake(b, false, []byte("yep"))
  65                 if err != nil {
  66                         t.Fatal(err)
  67                         return
  68                 }
  69                 var msg [20]byte
  70                 n, _ := b.Read(msg[:])
  71                 log.Print(string(msg[:n]))
  72                 b.Write([]byte("yo dawg"))
  73         }()
  74         wg.Wait()
  75 }