Update go dependencies
This commit is contained in:
Manuel de Brito Fontes
Manuel Alejandro de Brito Fontes
parent
15ffb51394
commit
bb4d483837
1621 changed files with 86368 additions and 284392 deletions
108
vendor/github.com/docker/spdystream/priority_test.go
generated
vendored
108
vendor/github.com/docker/spdystream/priority_test.go
generated
vendored
|
|
@ -1,108 +0,0 @@
|
|||
package spdystream
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/docker/spdystream/spdy"
|
||||
)
|
||||
|
||||
func TestPriorityQueueOrdering(t *testing.T) {
|
||||
queue := NewPriorityFrameQueue(150)
|
||||
data1 := &spdy.DataFrame{}
|
||||
data2 := &spdy.DataFrame{}
|
||||
data3 := &spdy.DataFrame{}
|
||||
data4 := &spdy.DataFrame{}
|
||||
queue.Push(data1, 2)
|
||||
queue.Push(data2, 1)
|
||||
queue.Push(data3, 1)
|
||||
queue.Push(data4, 0)
|
||||
|
||||
if queue.Pop() != data4 {
|
||||
t.Fatalf("Wrong order, expected data4 first")
|
||||
}
|
||||
if queue.Pop() != data2 {
|
||||
t.Fatalf("Wrong order, expected data2 second")
|
||||
}
|
||||
if queue.Pop() != data3 {
|
||||
t.Fatalf("Wrong order, expected data3 third")
|
||||
}
|
||||
if queue.Pop() != data1 {
|
||||
t.Fatalf("Wrong order, expected data1 fourth")
|
||||
}
|
||||
|
||||
// Insert 50 Medium priority frames
|
||||
for i := spdy.StreamId(50); i < 100; i++ {
|
||||
queue.Push(&spdy.DataFrame{StreamId: i}, 1)
|
||||
}
|
||||
// Insert 50 low priority frames
|
||||
for i := spdy.StreamId(100); i < 150; i++ {
|
||||
queue.Push(&spdy.DataFrame{StreamId: i}, 2)
|
||||
}
|
||||
// Insert 50 high priority frames
|
||||
for i := spdy.StreamId(0); i < 50; i++ {
|
||||
queue.Push(&spdy.DataFrame{StreamId: i}, 0)
|
||||
}
|
||||
|
||||
for i := spdy.StreamId(0); i < 150; i++ {
|
||||
frame := queue.Pop()
|
||||
if frame.(*spdy.DataFrame).StreamId != i {
|
||||
t.Fatalf("Wrong frame\nActual: %d\nExpecting: %d", frame.(*spdy.DataFrame).StreamId, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPriorityQueueSync(t *testing.T) {
|
||||
queue := NewPriorityFrameQueue(150)
|
||||
var wg sync.WaitGroup
|
||||
insertRange := func(start, stop spdy.StreamId, priority uint8) {
|
||||
for i := start; i < stop; i++ {
|
||||
queue.Push(&spdy.DataFrame{StreamId: i}, priority)
|
||||
}
|
||||
wg.Done()
|
||||
}
|
||||
wg.Add(3)
|
||||
go insertRange(spdy.StreamId(100), spdy.StreamId(150), 2)
|
||||
go insertRange(spdy.StreamId(0), spdy.StreamId(50), 0)
|
||||
go insertRange(spdy.StreamId(50), spdy.StreamId(100), 1)
|
||||
|
||||
wg.Wait()
|
||||
for i := spdy.StreamId(0); i < 150; i++ {
|
||||
frame := queue.Pop()
|
||||
if frame.(*spdy.DataFrame).StreamId != i {
|
||||
t.Fatalf("Wrong frame\nActual: %d\nExpecting: %d", frame.(*spdy.DataFrame).StreamId, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPriorityQueueBlocking(t *testing.T) {
|
||||
queue := NewPriorityFrameQueue(15)
|
||||
for i := 0; i < 15; i++ {
|
||||
queue.Push(&spdy.DataFrame{}, 2)
|
||||
}
|
||||
doneChan := make(chan bool)
|
||||
go func() {
|
||||
queue.Push(&spdy.DataFrame{}, 2)
|
||||
close(doneChan)
|
||||
}()
|
||||
select {
|
||||
case <-doneChan:
|
||||
t.Fatalf("Push succeeded, expected to block")
|
||||
case <-time.After(time.Millisecond):
|
||||
break
|
||||
}
|
||||
|
||||
queue.Pop()
|
||||
|
||||
select {
|
||||
case <-doneChan:
|
||||
break
|
||||
case <-time.After(time.Millisecond):
|
||||
t.Fatalf("Push should have succeeded, but timeout reached")
|
||||
}
|
||||
|
||||
for i := 0; i < 15; i++ {
|
||||
queue.Pop()
|
||||
}
|
||||
}
|
||||
644
vendor/github.com/docker/spdystream/spdy/spdy_test.go
generated
vendored
644
vendor/github.com/docker/spdystream/spdy/spdy_test.go
generated
vendored
|
|
@ -1,644 +0,0 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package spdy
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"encoding/base64"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var HeadersFixture = http.Header{
|
||||
"Url": []string{"http://www.google.com/"},
|
||||
"Method": []string{"get"},
|
||||
"Version": []string{"http/1.1"},
|
||||
}
|
||||
|
||||
func TestHeaderParsing(t *testing.T) {
|
||||
var headerValueBlockBuf bytes.Buffer
|
||||
writeHeaderValueBlock(&headerValueBlockBuf, HeadersFixture)
|
||||
const bogusStreamId = 1
|
||||
newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId)
|
||||
if err != nil {
|
||||
t.Fatal("parseHeaderValueBlock:", err)
|
||||
}
|
||||
if !reflect.DeepEqual(HeadersFixture, newHeaders) {
|
||||
t.Fatal("got: ", newHeaders, "\nwant: ", HeadersFixture)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseSynStreamFrameCompressionDisable(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
// Fixture framer for no compression test.
|
||||
framer := &Framer{
|
||||
headerCompressionDisabled: true,
|
||||
w: buffer,
|
||||
headerBuf: new(bytes.Buffer),
|
||||
r: buffer,
|
||||
}
|
||||
synStreamFrame := SynStreamFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSynStream,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
if err := framer.WriteFrame(&synStreamFrame); err != nil {
|
||||
t.Fatal("WriteFrame without compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame without compression:", err)
|
||||
}
|
||||
parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
|
||||
t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseSynStreamFrameCompressionEnable(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
synStreamFrame := SynStreamFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSynStream,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
if err := framer.WriteFrame(&synStreamFrame); err != nil {
|
||||
t.Fatal("WriteFrame with compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame with compression:", err)
|
||||
}
|
||||
parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
|
||||
t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseSynReplyFrameCompressionDisable(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer := &Framer{
|
||||
headerCompressionDisabled: true,
|
||||
w: buffer,
|
||||
headerBuf: new(bytes.Buffer),
|
||||
r: buffer,
|
||||
}
|
||||
synReplyFrame := SynReplyFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSynReply,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
if err := framer.WriteFrame(&synReplyFrame); err != nil {
|
||||
t.Fatal("WriteFrame without compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame without compression:", err)
|
||||
}
|
||||
parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
|
||||
t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseSynReplyFrameCompressionEnable(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
synReplyFrame := SynReplyFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSynReply,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
if err := framer.WriteFrame(&synReplyFrame); err != nil {
|
||||
t.Fatal("WriteFrame with compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame with compression:", err)
|
||||
}
|
||||
parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
|
||||
t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseRstStream(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
rstStreamFrame := RstStreamFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeRstStream,
|
||||
},
|
||||
StreamId: 1,
|
||||
Status: InvalidStream,
|
||||
}
|
||||
if err := framer.WriteFrame(&rstStreamFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedRstStreamFrame, ok := frame.(*RstStreamFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(rstStreamFrame, *parsedRstStreamFrame) {
|
||||
t.Fatal("got: ", *parsedRstStreamFrame, "\nwant: ", rstStreamFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseSettings(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
settingsFrame := SettingsFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSettings,
|
||||
},
|
||||
FlagIdValues: []SettingsFlagIdValue{
|
||||
{FlagSettingsPersistValue, SettingsCurrentCwnd, 10},
|
||||
{FlagSettingsPersisted, SettingsUploadBandwidth, 1},
|
||||
},
|
||||
}
|
||||
if err := framer.WriteFrame(&settingsFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedSettingsFrame, ok := frame.(*SettingsFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(settingsFrame, *parsedSettingsFrame) {
|
||||
t.Fatal("got: ", *parsedSettingsFrame, "\nwant: ", settingsFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParsePing(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
pingFrame := PingFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypePing,
|
||||
},
|
||||
Id: 31337,
|
||||
}
|
||||
if err := framer.WriteFrame(&pingFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
if pingFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Incorrect frame type:", pingFrame)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedPingFrame, ok := frame.(*PingFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if parsedPingFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Parsed incorrect frame type:", parsedPingFrame)
|
||||
}
|
||||
if !reflect.DeepEqual(pingFrame, *parsedPingFrame) {
|
||||
t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseGoAway(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
goAwayFrame := GoAwayFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeGoAway,
|
||||
},
|
||||
LastGoodStreamId: 31337,
|
||||
Status: 1,
|
||||
}
|
||||
if err := framer.WriteFrame(&goAwayFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
if goAwayFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Incorrect frame type:", goAwayFrame)
|
||||
}
|
||||
if goAwayFrame.CFHeader.length != 8 {
|
||||
t.Fatal("Incorrect frame type:", goAwayFrame)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedGoAwayFrame, ok := frame.(*GoAwayFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if parsedGoAwayFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
|
||||
}
|
||||
if parsedGoAwayFrame.CFHeader.length != 8 {
|
||||
t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
|
||||
}
|
||||
if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) {
|
||||
t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseHeadersFrame(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer := &Framer{
|
||||
headerCompressionDisabled: true,
|
||||
w: buffer,
|
||||
headerBuf: new(bytes.Buffer),
|
||||
r: buffer,
|
||||
}
|
||||
headersFrame := HeadersFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeHeaders,
|
||||
},
|
||||
StreamId: 2,
|
||||
}
|
||||
headersFrame.Headers = HeadersFixture
|
||||
if err := framer.WriteFrame(&headersFrame); err != nil {
|
||||
t.Fatal("WriteFrame without compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame without compression:", err)
|
||||
}
|
||||
parsedHeadersFrame, ok := frame.(*HeadersFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
|
||||
t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseHeadersFrameCompressionEnable(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
headersFrame := HeadersFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeHeaders,
|
||||
},
|
||||
StreamId: 2,
|
||||
}
|
||||
headersFrame.Headers = HeadersFixture
|
||||
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err := framer.WriteFrame(&headersFrame); err != nil {
|
||||
t.Fatal("WriteFrame with compression:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame with compression:", err)
|
||||
}
|
||||
parsedHeadersFrame, ok := frame.(*HeadersFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
|
||||
t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseWindowUpdateFrame(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
windowUpdateFrame := WindowUpdateFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeWindowUpdate,
|
||||
},
|
||||
StreamId: 31337,
|
||||
DeltaWindowSize: 1,
|
||||
}
|
||||
if err := framer.WriteFrame(&windowUpdateFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
if windowUpdateFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Incorrect frame type:", windowUpdateFrame)
|
||||
}
|
||||
if windowUpdateFrame.CFHeader.length != 8 {
|
||||
t.Fatal("Incorrect frame type:", windowUpdateFrame)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedWindowUpdateFrame, ok := frame.(*WindowUpdateFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if parsedWindowUpdateFrame.CFHeader.Flags != 0 {
|
||||
t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
|
||||
}
|
||||
if parsedWindowUpdateFrame.CFHeader.length != 8 {
|
||||
t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
|
||||
}
|
||||
if !reflect.DeepEqual(windowUpdateFrame, *parsedWindowUpdateFrame) {
|
||||
t.Fatal("got: ", *parsedWindowUpdateFrame, "\nwant: ", windowUpdateFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateParseDataFrame(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
dataFrame := DataFrame{
|
||||
StreamId: 1,
|
||||
Data: []byte{'h', 'e', 'l', 'l', 'o'},
|
||||
}
|
||||
if err := framer.WriteFrame(&dataFrame); err != nil {
|
||||
t.Fatal("WriteFrame:", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame:", err)
|
||||
}
|
||||
parsedDataFrame, ok := frame.(*DataFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(dataFrame, *parsedDataFrame) {
|
||||
t.Fatal("got: ", *parsedDataFrame, "\nwant: ", dataFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCompressionContextAcrossFrames(t *testing.T) {
|
||||
buffer := new(bytes.Buffer)
|
||||
framer, err := NewFramer(buffer, buffer)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create new framer:", err)
|
||||
}
|
||||
headersFrame := HeadersFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeHeaders,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
if err := framer.WriteFrame(&headersFrame); err != nil {
|
||||
t.Fatal("WriteFrame (HEADERS):", err)
|
||||
}
|
||||
synStreamFrame := SynStreamFrame{
|
||||
ControlFrameHeader{
|
||||
Version,
|
||||
TypeSynStream,
|
||||
0, // Flags
|
||||
0, // length
|
||||
},
|
||||
2, // StreamId
|
||||
0, // AssociatedTOStreamID
|
||||
0, // Priority
|
||||
1, // Slot
|
||||
nil, // Headers
|
||||
}
|
||||
synStreamFrame.Headers = HeadersFixture
|
||||
|
||||
if err := framer.WriteFrame(&synStreamFrame); err != nil {
|
||||
t.Fatal("WriteFrame (SYN_STREAM):", err)
|
||||
}
|
||||
frame, err := framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame (HEADERS):", err, buffer.Bytes())
|
||||
}
|
||||
parsedHeadersFrame, ok := frame.(*HeadersFrame)
|
||||
if !ok {
|
||||
t.Fatalf("expected HeadersFrame; got %T %v", frame, frame)
|
||||
}
|
||||
if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
|
||||
t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
|
||||
}
|
||||
frame, err = framer.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame (SYN_STREAM):", err, buffer.Bytes())
|
||||
}
|
||||
parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
|
||||
if !ok {
|
||||
t.Fatalf("expected SynStreamFrame; got %T %v", frame, frame)
|
||||
}
|
||||
if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
|
||||
t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultipleSPDYFrames(t *testing.T) {
|
||||
// Initialize the framers.
|
||||
pr1, pw1 := io.Pipe()
|
||||
pr2, pw2 := io.Pipe()
|
||||
writer, err := NewFramer(pw1, pr2)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create writer:", err)
|
||||
}
|
||||
reader, err := NewFramer(pw2, pr1)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to create reader:", err)
|
||||
}
|
||||
|
||||
// Set up the frames we're actually transferring.
|
||||
headersFrame := HeadersFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeHeaders,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
synStreamFrame := SynStreamFrame{
|
||||
CFHeader: ControlFrameHeader{
|
||||
version: Version,
|
||||
frameType: TypeSynStream,
|
||||
},
|
||||
StreamId: 2,
|
||||
Headers: HeadersFixture,
|
||||
}
|
||||
|
||||
// Start the goroutines to write the frames.
|
||||
go func() {
|
||||
if err := writer.WriteFrame(&headersFrame); err != nil {
|
||||
t.Fatal("WriteFrame (HEADERS): ", err)
|
||||
}
|
||||
if err := writer.WriteFrame(&synStreamFrame); err != nil {
|
||||
t.Fatal("WriteFrame (SYN_STREAM): ", err)
|
||||
}
|
||||
}()
|
||||
|
||||
// Read the frames and verify they look as expected.
|
||||
frame, err := reader.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame (HEADERS): ", err)
|
||||
}
|
||||
parsedHeadersFrame, ok := frame.(*HeadersFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type:", frame)
|
||||
}
|
||||
if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
|
||||
t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
|
||||
}
|
||||
frame, err = reader.ReadFrame()
|
||||
if err != nil {
|
||||
t.Fatal("ReadFrame (SYN_STREAM):", err)
|
||||
}
|
||||
parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
|
||||
if !ok {
|
||||
t.Fatal("Parsed incorrect frame type.")
|
||||
}
|
||||
if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
|
||||
t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadMalformedZlibHeader(t *testing.T) {
|
||||
// These were constructed by corrupting the first byte of the zlib
|
||||
// header after writing.
|
||||
malformedStructs := map[string]string{
|
||||
"SynStreamFrame": "gAIAAQAAABgAAAACAAAAAAAAF/nfolGyYmAAAAAA//8=",
|
||||
"SynReplyFrame": "gAIAAgAAABQAAAACAAAX+d+iUbJiYAAAAAD//w==",
|
||||
"HeadersFrame": "gAIACAAAABQAAAACAAAX+d+iUbJiYAAAAAD//w==",
|
||||
}
|
||||
for name, bad := range malformedStructs {
|
||||
b, err := base64.StdEncoding.DecodeString(bad)
|
||||
if err != nil {
|
||||
t.Errorf("Unable to decode base64 encoded frame %s: %v", name, err)
|
||||
}
|
||||
buf := bytes.NewBuffer(b)
|
||||
reader, err := NewFramer(buf, buf)
|
||||
if err != nil {
|
||||
t.Fatalf("NewFramer: %v", err)
|
||||
}
|
||||
_, err = reader.ReadFrame()
|
||||
if err != zlib.ErrHeader {
|
||||
t.Errorf("Frame %s, expected: %#v, actual: %#v", name, zlib.ErrHeader, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: these tests are too weak for updating SPDY spec. Fix me.
|
||||
|
||||
type zeroStream struct {
|
||||
frame Frame
|
||||
encoded string
|
||||
}
|
||||
|
||||
var streamIdZeroFrames = map[string]zeroStream{
|
||||
"SynStreamFrame": {
|
||||
&SynStreamFrame{StreamId: 0},
|
||||
"gAIAAQAAABgAAAAAAAAAAAAAePnfolGyYmAAAAAA//8=",
|
||||
},
|
||||
"SynReplyFrame": {
|
||||
&SynReplyFrame{StreamId: 0},
|
||||
"gAIAAgAAABQAAAAAAAB4+d+iUbJiYAAAAAD//w==",
|
||||
},
|
||||
"RstStreamFrame": {
|
||||
&RstStreamFrame{StreamId: 0},
|
||||
"gAIAAwAAAAgAAAAAAAAAAA==",
|
||||
},
|
||||
"HeadersFrame": {
|
||||
&HeadersFrame{StreamId: 0},
|
||||
"gAIACAAAABQAAAAAAAB4+d+iUbJiYAAAAAD//w==",
|
||||
},
|
||||
"DataFrame": {
|
||||
&DataFrame{StreamId: 0},
|
||||
"AAAAAAAAAAA=",
|
||||
},
|
||||
"PingFrame": {
|
||||
&PingFrame{Id: 0},
|
||||
"gAIABgAAAAQAAAAA",
|
||||
},
|
||||
}
|
||||
|
||||
func TestNoZeroStreamId(t *testing.T) {
|
||||
t.Log("skipping") // TODO: update to work with SPDY3
|
||||
return
|
||||
|
||||
for name, f := range streamIdZeroFrames {
|
||||
b, err := base64.StdEncoding.DecodeString(f.encoded)
|
||||
if err != nil {
|
||||
t.Errorf("Unable to decode base64 encoded frame %s: %v", f, err)
|
||||
continue
|
||||
}
|
||||
framer, err := NewFramer(ioutil.Discard, bytes.NewReader(b))
|
||||
if err != nil {
|
||||
t.Fatalf("NewFramer: %v", err)
|
||||
}
|
||||
err = framer.WriteFrame(f.frame)
|
||||
checkZeroStreamId(t, name, "WriteFrame", err)
|
||||
|
||||
_, err = framer.ReadFrame()
|
||||
checkZeroStreamId(t, name, "ReadFrame", err)
|
||||
}
|
||||
}
|
||||
|
||||
func checkZeroStreamId(t *testing.T, frame string, method string, err error) {
|
||||
if err == nil {
|
||||
t.Errorf("%s ZeroStreamId, no error on %s", method, frame)
|
||||
return
|
||||
}
|
||||
eerr, ok := err.(*Error)
|
||||
if !ok || eerr.Err != ZeroStreamId {
|
||||
t.Errorf("%s ZeroStreamId, incorrect error %#v, frame %s", method, eerr, frame)
|
||||
}
|
||||
}
|
||||
113
vendor/github.com/docker/spdystream/spdy_bench_test.go
generated
vendored
113
vendor/github.com/docker/spdystream/spdy_bench_test.go
generated
vendored
|
|
@ -1,113 +0,0 @@
|
|||
package spdystream
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func configureServer() (io.Closer, string, *sync.WaitGroup) {
|
||||
authenticated = true
|
||||
wg := &sync.WaitGroup{}
|
||||
server, listen, serverErr := runServer(wg)
|
||||
|
||||
if serverErr != nil {
|
||||
panic(serverErr)
|
||||
}
|
||||
|
||||
return server, listen, wg
|
||||
}
|
||||
|
||||
func BenchmarkDial10000(b *testing.B) {
|
||||
server, addr, wg := configureServer()
|
||||
|
||||
defer func() {
|
||||
server.Close()
|
||||
wg.Wait()
|
||||
}()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
conn, dialErr := net.Dial("tcp", addr)
|
||||
if dialErr != nil {
|
||||
panic(fmt.Sprintf("Error dialing server: %s", dialErr))
|
||||
}
|
||||
conn.Close()
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkDialWithSPDYStream10000(b *testing.B) {
|
||||
server, addr, wg := configureServer()
|
||||
|
||||
defer func() {
|
||||
server.Close()
|
||||
wg.Wait()
|
||||
}()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
conn, dialErr := net.Dial("tcp", addr)
|
||||
if dialErr != nil {
|
||||
b.Fatalf("Error dialing server: %s", dialErr)
|
||||
}
|
||||
|
||||
spdyConn, spdyErr := NewConnection(conn, false)
|
||||
if spdyErr != nil {
|
||||
b.Fatalf("Error creating spdy connection: %s", spdyErr)
|
||||
}
|
||||
go spdyConn.Serve(NoOpStreamHandler)
|
||||
|
||||
closeErr := spdyConn.Close()
|
||||
if closeErr != nil {
|
||||
b.Fatalf("Error closing connection: %s, closeErr")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkStreamWithDataAndSize(size uint64, b *testing.B) {
|
||||
server, addr, wg := configureServer()
|
||||
|
||||
defer func() {
|
||||
server.Close()
|
||||
wg.Wait()
|
||||
}()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
conn, dialErr := net.Dial("tcp", addr)
|
||||
if dialErr != nil {
|
||||
b.Fatalf("Error dialing server: %s", dialErr)
|
||||
}
|
||||
|
||||
spdyConn, spdyErr := NewConnection(conn, false)
|
||||
if spdyErr != nil {
|
||||
b.Fatalf("Error creating spdy connection: %s", spdyErr)
|
||||
}
|
||||
|
||||
go spdyConn.Serve(MirrorStreamHandler)
|
||||
|
||||
stream, err := spdyConn.CreateStream(http.Header{}, nil, false)
|
||||
|
||||
writer := make([]byte, size)
|
||||
|
||||
stream.Write(writer)
|
||||
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
reader := make([]byte, size)
|
||||
stream.Read(reader)
|
||||
|
||||
stream.Close()
|
||||
|
||||
closeErr := spdyConn.Close()
|
||||
if closeErr != nil {
|
||||
b.Fatalf("Error closing connection: %s, closeErr")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStreamWith1Byte10000(b *testing.B) { benchmarkStreamWithDataAndSize(1, b) }
|
||||
func BenchmarkStreamWith1KiloByte10000(b *testing.B) { benchmarkStreamWithDataAndSize(1024, b) }
|
||||
func BenchmarkStreamWith1Megabyte10000(b *testing.B) { benchmarkStreamWithDataAndSize(1024*1024, b) }
|
||||
1171
vendor/github.com/docker/spdystream/spdy_test.go
generated
vendored
1171
vendor/github.com/docker/spdystream/spdy_test.go
generated
vendored
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue