gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

use stream numbers, not stream ids, in the stream maps

Browse Source
This commit is contained in:
Marten Seemann
2019-06-05 19:59:39 +08:00
parent a8633a952c
commit 857e4ae9a9
12 changed files with 524 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
streams_map_outgoing_generic_test.go
View File

@@ -5,27 +5,24 @@ import (
"github.com/golang/mock/gomock"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/qerr"
"github.com/lucas-clemente/quic-go/internal/wire"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Streams Map (outgoing)", func() {
const firstNewStream protocol.StreamID = 3
var (
m *outgoingItemsMap
newItem func(id protocol.StreamID) item
newItem func(num protocol.StreamNum) item
mockSender *MockStreamSender
)
BeforeEach(func() {
newItem = func(id protocol.StreamID) item {
return &mockGenericStream{id: id}
newItem = func(num protocol.StreamNum) item {
return &mockGenericStream{num: num}
}
mockSender = NewMockStreamSender(mockCtrl)
m = newOutgoingItemsMap(firstNewStream, newItem, mockSender.queueControlFrame)
m = newOutgoingItemsMap(newItem, mockSender.queueControlFrame)
})
Context("no stream ID limit", func() {
@@ -36,10 +33,10 @@ var _ = Describe("Streams Map (outgoing)", func() {
It("opens streams", func() {
str, err := m.OpenStream()
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(Equal(firstNewStream))
Expect(str.(*mockGenericStream).num).To(Equal(protocol.StreamNum(1)))
str, err = m.OpenStream()
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(Equal(firstNewStream + 4))
Expect(str.(*mockGenericStream).num).To(Equal(protocol.StreamNum(2)))
})
It("doesn't open streams after it has been closed", func() {
@@ -52,38 +49,40 @@ var _ = Describe("Streams Map (outgoing)", func() {
It("gets streams", func() {
_, err := m.OpenStream()
Expect(err).ToNot(HaveOccurred())
str, err := m.GetStream(firstNewStream)
str, err := m.GetStream(1)
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(Equal(firstNewStream))
Expect(str.(*mockGenericStream).num).To(Equal(protocol.StreamNum(1)))
})
It("errors when trying to get a stream that has not yet been opened", func() {
_, err := m.GetStream(firstNewStream)
Expect(err).To(MatchError(qerr.Error(qerr.StreamStateError, "peer attempted to open stream 3")))
_, err := m.GetStream(1)
Expect(err).To(HaveOccurred())
Expect(err.(streamError).TestError()).To(MatchError("peer attempted to open stream 1"))
})
It("deletes streams", func() {
_, err := m.OpenStream() // opens firstNewStream
_, err := m.OpenStream()
Expect(err).ToNot(HaveOccurred())
err = m.DeleteStream(firstNewStream)
Expect(m.DeleteStream(1)).To(Succeed())
Expect(err).ToNot(HaveOccurred())
str, err := m.GetStream(firstNewStream)
str, err := m.GetStream(1)
Expect(err).ToNot(HaveOccurred())
Expect(str).To(BeNil())
})
It("errors when deleting a non-existing stream", func() {
err := m.DeleteStream(1337)
Expect(err).To(MatchError("Tried to delete unknown stream 1337"))
Expect(err).To(HaveOccurred())
Expect(err.(streamError).TestError()).To(MatchError("Tried to delete unknown stream 1337"))
})
It("errors when deleting a stream twice", func() {
_, err := m.OpenStream() // opens firstNewStream
Expect(err).ToNot(HaveOccurred())
err = m.DeleteStream(firstNewStream)
Expect(err).ToNot(HaveOccurred())
err = m.DeleteStream(firstNewStream)
Expect(err).To(MatchError("Tried to delete unknown stream 3"))
Expect(m.DeleteStream(1)).To(Succeed())
err = m.DeleteStream(1)
Expect(err).To(HaveOccurred())
Expect(err.(streamError).TestError()).To(MatchError("Tried to delete unknown stream 1"))
})
It("closes all streams when CloseWithError is called", func() {
@@ -114,31 +113,12 @@ var _ = Describe("Streams Map (outgoing)", func() {
defer GinkgoRecover()
str, err := m.OpenStreamSync()
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(Equal(firstNewStream))
Expect(str.(*mockGenericStream).num).To(Equal(protocol.StreamNum(1)))
close(done)
}()
Consistently(done).ShouldNot(BeClosed())
m.SetMaxStream(firstNewStream)
Eventually(done).Should(BeClosed())
})
It("works with stream 0", func() {
m = newOutgoingItemsMap(0, newItem, mockSender.queueControlFrame)
mockSender.EXPECT().queueControlFrame(gomock.Any()).Do(func(f wire.Frame) {
Expect(f.(*wire.StreamsBlockedFrame).StreamLimit).To(BeZero())
})
done := make(chan struct{})
go func() {
defer GinkgoRecover()
str, err := m.OpenStreamSync()
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(BeZero())
close(done)
}()
Consistently(done).ShouldNot(BeClosed())
m.SetMaxStream(0)
m.SetMaxStream(1)
Eventually(done).Should(BeClosed())
})
@@ -159,17 +139,17 @@ var _ = Describe("Streams Map (outgoing)", func() {
})
It("doesn't reduce the stream limit", func() {
m.SetMaxStream(firstNewStream + 4)
m.SetMaxStream(firstNewStream)
m.SetMaxStream(2)
m.SetMaxStream(1)
_, err := m.OpenStream()
Expect(err).ToNot(HaveOccurred())
str, err := m.OpenStream()
Expect(err).ToNot(HaveOccurred())
Expect(str.(*mockGenericStream).id).To(Equal(firstNewStream + 4))
Expect(str.(*mockGenericStream).num).To(Equal(protocol.StreamNum(2)))
})
It("queues a STREAM_ID_BLOCKED frame if no stream can be opened", func() {
m.SetMaxStream(firstNewStream + 5*4)
m.SetMaxStream(6)
// open the 6 allowed streams
for i := 0; i < 6; i++ {
_, err := m.OpenStream()
@@ -185,7 +165,7 @@ var _ = Describe("Streams Map (outgoing)", func() {
})
It("only sends one STREAM_ID_BLOCKED frame for one stream ID", func() {
m.SetMaxStream(firstNewStream)
m.SetMaxStream(1)
mockSender.EXPECT().queueControlFrame(gomock.Any()).Do(func(f wire.Frame) {
Expect(f.(*wire.StreamsBlockedFrame).StreamLimit).To(BeEquivalentTo(1))
})