vendor/google.golang.org/grpc/test/bufconn/bufconn_test.go

   1 /*
   2  *
   3  * Copyright 2017 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 package bufconn
  20
  21 import (
  22         "fmt"
  23         "io"
  24         "net"
  25         "reflect"
  26         "testing"
  27         "time"
  28 )
  29
  30 func testRW(r io.Reader, w io.Writer) error {
  31         for i := 0; i < 20; i++ {
  32                 d := make([]byte, i)
  33                 for j := 0; j < i; j++ {
  34                         d[j] = byte(i - j)
  35                 }
  36                 var rn int
  37                 var rerr error
  38                 b := make([]byte, i)
  39                 done := make(chan struct{})
  40                 go func() {
  41                         for rn < len(b) && rerr == nil {
  42                                 var x int
  43                                 x, rerr = r.Read(b[rn:])
  44                                 rn += x
  45                         }
  46                         close(done)
  47                 }()
  48                 wn, werr := w.Write(d)
  49                 if wn != i || werr != nil {
  50                         return fmt.Errorf("%v: w.Write(%v) = %v, %v; want %v, nil", i, d, wn, werr, i)
  51                 }
  52                 select {
  53                 case <-done:
  54                 case <-time.After(500 * time.Millisecond):
  55                         return fmt.Errorf("%v: r.Read never returned", i)
  56                 }
  57                 if rn != i || rerr != nil {
  58                         return fmt.Errorf("%v: r.Read = %v, %v; want %v, nil", i, rn, rerr, i)
  59                 }
  60                 if !reflect.DeepEqual(b, d) {
  61                         return fmt.Errorf("%v: r.Read read %v; want %v", i, b, d)
  62                 }
  63         }
  64         return nil
  65 }
  66
  67 func TestPipe(t *testing.T) {
  68         p := newPipe(10)
  69         if err := testRW(p, p); err != nil {
  70                 t.Fatalf(err.Error())
  71         }
  72 }
  73
  74 func TestPipeClose(t *testing.T) {
  75         p := newPipe(10)
  76         p.Close()
  77         if _, err := p.Write(nil); err != io.ErrClosedPipe {
  78                 t.Fatalf("p.Write = _, %v; want _, %v", err, io.ErrClosedPipe)
  79         }
  80         if _, err := p.Read(nil); err != io.ErrClosedPipe {
  81                 t.Fatalf("p.Read = _, %v; want _, %v", err, io.ErrClosedPipe)
  82         }
  83 }
  84
  85 func TestConn(t *testing.T) {
  86         p1, p2 := newPipe(10), newPipe(10)
  87         c1, c2 := &conn{p1, p2}, &conn{p2, p1}
  88
  89         if err := testRW(c1, c2); err != nil {
  90                 t.Fatalf(err.Error())
  91         }
  92         if err := testRW(c2, c1); err != nil {
  93                 t.Fatalf(err.Error())
  94         }
  95 }
  96
  97 func TestListener(t *testing.T) {
  98         l := Listen(7)
  99         var s net.Conn
 100         var serr error
 101         done := make(chan struct{})
 102         go func() {
 103                 s, serr = l.Accept()
 104                 close(done)
 105         }()
 106         c, cerr := l.Dial()
 107         <-done
 108         if cerr != nil || serr != nil {
 109                 t.Fatalf("cerr = %v, serr = %v; want nil, nil", cerr, serr)
 110         }
 111         if err := testRW(c, s); err != nil {
 112                 t.Fatalf(err.Error())
 113         }
 114         if err := testRW(s, c); err != nil {
 115                 t.Fatalf(err.Error())
 116         }
 117 }
 118
 119 func TestCloseWhileDialing(t *testing.T) {
 120         l := Listen(7)
 121         var c net.Conn
 122         var err error
 123         done := make(chan struct{})
 124         go func() {
 125                 c, err = l.Dial()
 126                 close(done)
 127         }()
 128         l.Close()
 129         <-done
 130         if c != nil || err != errClosed {
 131                 t.Fatalf("c, err = %v, %v; want nil, %v", c, err, errClosed)
 132         }
 133 }
 134
 135 func TestCloseWhileAccepting(t *testing.T) {
 136         l := Listen(7)
 137         var c net.Conn
 138         var err error
 139         done := make(chan struct{})
 140         go func() {
 141                 c, err = l.Accept()
 142                 close(done)
 143         }()
 144         l.Close()
 145         <-done
 146         if c != nil || err != errClosed {
 147                 t.Fatalf("c, err = %v, %v; want nil, %v", c, err, errClosed)
 148         }
 149 }