Method TestRecvBufferPoolStream

experimental/shared_buffer_pool_test.go:48–132

(t *testing.T)

const defaultTestTimeout = 10 * time.Second

func (s) TestRecvBufferPoolStream(t *testing.T) {
	// TODO: How much of this test can be preserved now that buffer reuse happens at
	// the codec and HTTP/2 level?
	t.SkipNow()
	tcs := []struct {
		name     string
		callOpts []grpc.CallOption
	}{
		{
			name: "default",
		},
		{
			name: "useCompressor",
			callOpts: []grpc.CallOption{
				grpc.UseCompressor(gzip.Name),
			},
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			const reqCount = 10

			ss := &stubserver.StubServer{
				FullDuplexCallF: func(stream testgrpc.TestService_FullDuplexCallServer) error {
					for i := 0; i < reqCount; i++ {
						preparedMsg := &grpc.PreparedMsg{}
						if err := preparedMsg.Encode(stream, &testpb.StreamingOutputCallResponse{
							Payload: &testpb.Payload{
								Body: []byte{'0' + uint8(i)},
							},
						}); err != nil {
							return err
						}
						stream.SendMsg(preparedMsg)
					}
					return nil
				},
			}

			pool := &checkBufferPool{}
			sopts := []grpc.ServerOption{experimental.BufferPool(pool)}
			dopts := []grpc.DialOption{experimental.WithBufferPool(pool)}
			if err := ss.Start(sopts, dopts...); err != nil {
				t.Fatalf("Error starting endpoint server: %v", err)
			}
			defer ss.Stop()

			ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
			defer cancel()

			stream, err := ss.Client.FullDuplexCall(ctx, tc.callOpts...)
			if err != nil {
				t.Fatalf("ss.Client.FullDuplexCall failed: %v", err)
			}

			var ngot int
			var buf bytes.Buffer