← Back to branch summary

~juju-qa/ubuntu/yakkety/juju/2.0-rc3-again

« back to all changes in this revision

Viewing changes to src/code.google.com/p/go.net/spdy/spdy_test.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-04-24 22:34:47 UTC
  • Revision ID: package-import@ubuntu.com-20130424223447-f0qdji7ubnyo0s71
Tags: upstream-1.10.0.1
Import upstream version 1.10.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/code.google.com/p/go.net/spdy/spdy_test.go
 
1
// Copyright 2011 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package spdy
 
6
 
 
7
import (
 
8
        "bytes"
 
9
        "compress/zlib"
 
10
        "encoding/base64"
 
11
        "io"
 
12
        "io/ioutil"
 
13
        "net/http"
 
14
        "reflect"
 
15
        "testing"
 
16
)
 
17
 
 
18
func TestHeaderParsing(t *testing.T) {
 
19
        headers := http.Header{
 
20
                "Url":     []string{"http://www.google.com/"},
 
21
                "Method":  []string{"get"},
 
22
                "Version": []string{"http/1.1"},
 
23
        }
 
24
        var headerValueBlockBuf bytes.Buffer
 
25
        writeHeaderValueBlock(&headerValueBlockBuf, headers)
 
26
 
 
27
        const bogusStreamId = 1
 
28
        newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId)
 
29
        if err != nil {
 
30
                t.Fatal("parseHeaderValueBlock:", err)
 
31
        }
 
32
 
 
33
        if !reflect.DeepEqual(headers, newHeaders) {
 
34
                t.Fatal("got: ", newHeaders, "\nwant: ", headers)
 
35
        }
 
36
}
 
37
 
 
38
func TestCreateParseSynStreamFrame(t *testing.T) {
 
39
        buffer := new(bytes.Buffer)
 
40
        framer := &Framer{
 
41
                headerCompressionDisabled: true,
 
42
                w:         buffer,
 
43
                headerBuf: new(bytes.Buffer),
 
44
                r:         buffer,
 
45
        }
 
46
        synStreamFrame := SynStreamFrame{
 
47
                CFHeader: ControlFrameHeader{
 
48
                        version:   Version,
 
49
                        frameType: TypeSynStream,
 
50
                },
 
51
                StreamId: 2,
 
52
                Headers: http.Header{
 
53
                        "Url":     []string{"http://www.google.com/"},
 
54
                        "Method":  []string{"get"},
 
55
                        "Version": []string{"http/1.1"},
 
56
                },
 
57
        }
 
58
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
 
59
                t.Fatal("WriteFrame without compression:", err)
 
60
        }
 
61
        frame, err := framer.ReadFrame()
 
62
        if err != nil {
 
63
                t.Fatal("ReadFrame without compression:", err)
 
64
        }
 
65
        parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
 
66
        if !ok {
 
67
                t.Fatal("Parsed incorrect frame type:", frame)
 
68
        }
 
69
        if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 
70
                t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 
71
        }
 
72
 
 
73
        // Test again with compression
 
74
        buffer.Reset()
 
75
        framer, err = NewFramer(buffer, buffer)
 
76
        if err != nil {
 
77
                t.Fatal("Failed to create new framer:", err)
 
78
        }
 
79
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
 
80
                t.Fatal("WriteFrame with compression:", err)
 
81
        }
 
82
        frame, err = framer.ReadFrame()
 
83
        if err != nil {
 
84
                t.Fatal("ReadFrame with compression:", err)
 
85
        }
 
86
        parsedSynStreamFrame, ok = frame.(*SynStreamFrame)
 
87
        if !ok {
 
88
                t.Fatal("Parsed incorrect frame type:", frame)
 
89
        }
 
90
        if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 
91
                t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 
92
        }
 
93
}
 
94
 
 
95
func TestCreateParseSynReplyFrame(t *testing.T) {
 
96
        buffer := new(bytes.Buffer)
 
97
        framer := &Framer{
 
98
                headerCompressionDisabled: true,
 
99
                w:         buffer,
 
100
                headerBuf: new(bytes.Buffer),
 
101
                r:         buffer,
 
102
        }
 
103
        synReplyFrame := SynReplyFrame{
 
104
                CFHeader: ControlFrameHeader{
 
105
                        version:   Version,
 
106
                        frameType: TypeSynReply,
 
107
                },
 
108
                StreamId: 2,
 
109
                Headers: http.Header{
 
110
                        "Url":     []string{"http://www.google.com/"},
 
111
                        "Method":  []string{"get"},
 
112
                        "Version": []string{"http/1.1"},
 
113
                },
 
114
        }
 
115
        if err := framer.WriteFrame(&synReplyFrame); err != nil {
 
116
                t.Fatal("WriteFrame without compression:", err)
 
117
        }
 
118
        frame, err := framer.ReadFrame()
 
119
        if err != nil {
 
120
                t.Fatal("ReadFrame without compression:", err)
 
121
        }
 
122
        parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
 
123
        if !ok {
 
124
                t.Fatal("Parsed incorrect frame type:", frame)
 
125
        }
 
126
        if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
 
127
                t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
 
128
        }
 
129
 
 
130
        // Test again with compression
 
131
        buffer.Reset()
 
132
        framer, err = NewFramer(buffer, buffer)
 
133
        if err != nil {
 
134
                t.Fatal("Failed to create new framer:", err)
 
135
        }
 
136
        if err := framer.WriteFrame(&synReplyFrame); err != nil {
 
137
                t.Fatal("WriteFrame with compression:", err)
 
138
        }
 
139
        frame, err = framer.ReadFrame()
 
140
        if err != nil {
 
141
                t.Fatal("ReadFrame with compression:", err)
 
142
        }
 
143
        parsedSynReplyFrame, ok = frame.(*SynReplyFrame)
 
144
        if !ok {
 
145
                t.Fatal("Parsed incorrect frame type:", frame)
 
146
        }
 
147
        if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
 
148
                t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
 
149
        }
 
150
}
 
151
 
 
152
func TestCreateParseRstStream(t *testing.T) {
 
153
        buffer := new(bytes.Buffer)
 
154
        framer, err := NewFramer(buffer, buffer)
 
155
        if err != nil {
 
156
                t.Fatal("Failed to create new framer:", err)
 
157
        }
 
158
        rstStreamFrame := RstStreamFrame{
 
159
                CFHeader: ControlFrameHeader{
 
160
                        version:   Version,
 
161
                        frameType: TypeRstStream,
 
162
                },
 
163
                StreamId: 1,
 
164
                Status:   InvalidStream,
 
165
        }
 
166
        if err := framer.WriteFrame(&rstStreamFrame); err != nil {
 
167
                t.Fatal("WriteFrame:", err)
 
168
        }
 
169
        frame, err := framer.ReadFrame()
 
170
        if err != nil {
 
171
                t.Fatal("ReadFrame:", err)
 
172
        }
 
173
        parsedRstStreamFrame, ok := frame.(*RstStreamFrame)
 
174
        if !ok {
 
175
                t.Fatal("Parsed incorrect frame type:", frame)
 
176
        }
 
177
        if !reflect.DeepEqual(rstStreamFrame, *parsedRstStreamFrame) {
 
178
                t.Fatal("got: ", *parsedRstStreamFrame, "\nwant: ", rstStreamFrame)
 
179
        }
 
180
}
 
181
 
 
182
func TestCreateParseSettings(t *testing.T) {
 
183
        buffer := new(bytes.Buffer)
 
184
        framer, err := NewFramer(buffer, buffer)
 
185
        if err != nil {
 
186
                t.Fatal("Failed to create new framer:", err)
 
187
        }
 
188
        settingsFrame := SettingsFrame{
 
189
                CFHeader: ControlFrameHeader{
 
190
                        version:   Version,
 
191
                        frameType: TypeSettings,
 
192
                },
 
193
                FlagIdValues: []SettingsFlagIdValue{
 
194
                        {FlagSettingsPersistValue, SettingsCurrentCwnd, 10},
 
195
                        {FlagSettingsPersisted, SettingsUploadBandwidth, 1},
 
196
                },
 
197
        }
 
198
        if err := framer.WriteFrame(&settingsFrame); err != nil {
 
199
                t.Fatal("WriteFrame:", err)
 
200
        }
 
201
        frame, err := framer.ReadFrame()
 
202
        if err != nil {
 
203
                t.Fatal("ReadFrame:", err)
 
204
        }
 
205
        parsedSettingsFrame, ok := frame.(*SettingsFrame)
 
206
        if !ok {
 
207
                t.Fatal("Parsed incorrect frame type:", frame)
 
208
        }
 
209
        if !reflect.DeepEqual(settingsFrame, *parsedSettingsFrame) {
 
210
                t.Fatal("got: ", *parsedSettingsFrame, "\nwant: ", settingsFrame)
 
211
        }
 
212
}
 
213
 
 
214
func TestCreateParseNoop(t *testing.T) {
 
215
        buffer := new(bytes.Buffer)
 
216
        framer, err := NewFramer(buffer, buffer)
 
217
        if err != nil {
 
218
                t.Fatal("Failed to create new framer:", err)
 
219
        }
 
220
        noopFrame := NoopFrame{
 
221
                CFHeader: ControlFrameHeader{
 
222
                        version:   Version,
 
223
                        frameType: TypeNoop,
 
224
                },
 
225
        }
 
226
        if err := framer.WriteFrame(&noopFrame); err != nil {
 
227
                t.Fatal("WriteFrame:", err)
 
228
        }
 
229
        frame, err := framer.ReadFrame()
 
230
        if err != nil {
 
231
                t.Fatal("ReadFrame:", err)
 
232
        }
 
233
        parsedNoopFrame, ok := frame.(*NoopFrame)
 
234
        if !ok {
 
235
                t.Fatal("Parsed incorrect frame type:", frame)
 
236
        }
 
237
        if !reflect.DeepEqual(noopFrame, *parsedNoopFrame) {
 
238
                t.Fatal("got: ", *parsedNoopFrame, "\nwant: ", noopFrame)
 
239
        }
 
240
}
 
241
 
 
242
func TestCreateParsePing(t *testing.T) {
 
243
        buffer := new(bytes.Buffer)
 
244
        framer, err := NewFramer(buffer, buffer)
 
245
        if err != nil {
 
246
                t.Fatal("Failed to create new framer:", err)
 
247
        }
 
248
        pingFrame := PingFrame{
 
249
                CFHeader: ControlFrameHeader{
 
250
                        version:   Version,
 
251
                        frameType: TypePing,
 
252
                },
 
253
                Id: 31337,
 
254
        }
 
255
        if err := framer.WriteFrame(&pingFrame); err != nil {
 
256
                t.Fatal("WriteFrame:", err)
 
257
        }
 
258
        frame, err := framer.ReadFrame()
 
259
        if err != nil {
 
260
                t.Fatal("ReadFrame:", err)
 
261
        }
 
262
        parsedPingFrame, ok := frame.(*PingFrame)
 
263
        if !ok {
 
264
                t.Fatal("Parsed incorrect frame type:", frame)
 
265
        }
 
266
        if !reflect.DeepEqual(pingFrame, *parsedPingFrame) {
 
267
                t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame)
 
268
        }
 
269
}
 
270
 
 
271
func TestCreateParseGoAway(t *testing.T) {
 
272
        buffer := new(bytes.Buffer)
 
273
        framer, err := NewFramer(buffer, buffer)
 
274
        if err != nil {
 
275
                t.Fatal("Failed to create new framer:", err)
 
276
        }
 
277
        goAwayFrame := GoAwayFrame{
 
278
                CFHeader: ControlFrameHeader{
 
279
                        version:   Version,
 
280
                        frameType: TypeGoAway,
 
281
                },
 
282
                LastGoodStreamId: 31337,
 
283
        }
 
284
        if err := framer.WriteFrame(&goAwayFrame); err != nil {
 
285
                t.Fatal("WriteFrame:", err)
 
286
        }
 
287
        frame, err := framer.ReadFrame()
 
288
        if err != nil {
 
289
                t.Fatal("ReadFrame:", err)
 
290
        }
 
291
        parsedGoAwayFrame, ok := frame.(*GoAwayFrame)
 
292
        if !ok {
 
293
                t.Fatal("Parsed incorrect frame type:", frame)
 
294
        }
 
295
        if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) {
 
296
                t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame)
 
297
        }
 
298
}
 
299
 
 
300
func TestCreateParseHeadersFrame(t *testing.T) {
 
301
        buffer := new(bytes.Buffer)
 
302
        framer := &Framer{
 
303
                headerCompressionDisabled: true,
 
304
                w:         buffer,
 
305
                headerBuf: new(bytes.Buffer),
 
306
                r:         buffer,
 
307
        }
 
308
        headersFrame := HeadersFrame{
 
309
                CFHeader: ControlFrameHeader{
 
310
                        version:   Version,
 
311
                        frameType: TypeHeaders,
 
312
                },
 
313
                StreamId: 2,
 
314
        }
 
315
        headersFrame.Headers = http.Header{
 
316
                "Url":     []string{"http://www.google.com/"},
 
317
                "Method":  []string{"get"},
 
318
                "Version": []string{"http/1.1"},
 
319
        }
 
320
        if err := framer.WriteFrame(&headersFrame); err != nil {
 
321
                t.Fatal("WriteFrame without compression:", err)
 
322
        }
 
323
        frame, err := framer.ReadFrame()
 
324
        if err != nil {
 
325
                t.Fatal("ReadFrame without compression:", err)
 
326
        }
 
327
        parsedHeadersFrame, ok := frame.(*HeadersFrame)
 
328
        if !ok {
 
329
                t.Fatal("Parsed incorrect frame type:", frame)
 
330
        }
 
331
        if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 
332
                t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 
333
        }
 
334
 
 
335
        // Test again with compression
 
336
        buffer.Reset()
 
337
        framer, err = NewFramer(buffer, buffer)
 
338
        if err := framer.WriteFrame(&headersFrame); err != nil {
 
339
                t.Fatal("WriteFrame with compression:", err)
 
340
        }
 
341
        frame, err = framer.ReadFrame()
 
342
        if err != nil {
 
343
                t.Fatal("ReadFrame with compression:", err)
 
344
        }
 
345
        parsedHeadersFrame, ok = frame.(*HeadersFrame)
 
346
        if !ok {
 
347
                t.Fatal("Parsed incorrect frame type:", frame)
 
348
        }
 
349
        if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 
350
                t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 
351
        }
 
352
}
 
353
 
 
354
func TestCreateParseDataFrame(t *testing.T) {
 
355
        buffer := new(bytes.Buffer)
 
356
        framer, err := NewFramer(buffer, buffer)
 
357
        if err != nil {
 
358
                t.Fatal("Failed to create new framer:", err)
 
359
        }
 
360
        dataFrame := DataFrame{
 
361
                StreamId: 1,
 
362
                Data:     []byte{'h', 'e', 'l', 'l', 'o'},
 
363
        }
 
364
        if err := framer.WriteFrame(&dataFrame); err != nil {
 
365
                t.Fatal("WriteFrame:", err)
 
366
        }
 
367
        frame, err := framer.ReadFrame()
 
368
        if err != nil {
 
369
                t.Fatal("ReadFrame:", err)
 
370
        }
 
371
        parsedDataFrame, ok := frame.(*DataFrame)
 
372
        if !ok {
 
373
                t.Fatal("Parsed incorrect frame type:", frame)
 
374
        }
 
375
        if !reflect.DeepEqual(dataFrame, *parsedDataFrame) {
 
376
                t.Fatal("got: ", *parsedDataFrame, "\nwant: ", dataFrame)
 
377
        }
 
378
}
 
379
 
 
380
func TestCompressionContextAcrossFrames(t *testing.T) {
 
381
        buffer := new(bytes.Buffer)
 
382
        framer, err := NewFramer(buffer, buffer)
 
383
        if err != nil {
 
384
                t.Fatal("Failed to create new framer:", err)
 
385
        }
 
386
        headersFrame := HeadersFrame{
 
387
                CFHeader: ControlFrameHeader{
 
388
                        version:   Version,
 
389
                        frameType: TypeHeaders,
 
390
                },
 
391
                StreamId: 2,
 
392
                Headers: http.Header{
 
393
                        "Url":     []string{"http://www.google.com/"},
 
394
                        "Method":  []string{"get"},
 
395
                        "Version": []string{"http/1.1"},
 
396
                },
 
397
        }
 
398
        if err := framer.WriteFrame(&headersFrame); err != nil {
 
399
                t.Fatal("WriteFrame (HEADERS):", err)
 
400
        }
 
401
        synStreamFrame := SynStreamFrame{ControlFrameHeader{Version, TypeSynStream, 0, 0}, 2, 0, 0, nil}
 
402
        synStreamFrame.Headers = http.Header{
 
403
                "Url":     []string{"http://www.google.com/"},
 
404
                "Method":  []string{"get"},
 
405
                "Version": []string{"http/1.1"},
 
406
        }
 
407
        if err := framer.WriteFrame(&synStreamFrame); err != nil {
 
408
                t.Fatal("WriteFrame (SYN_STREAM):", err)
 
409
        }
 
410
        frame, err := framer.ReadFrame()
 
411
        if err != nil {
 
412
                t.Fatal("ReadFrame (HEADERS):", err, buffer.Bytes())
 
413
        }
 
414
        parsedHeadersFrame, ok := frame.(*HeadersFrame)
 
415
        if !ok {
 
416
                t.Fatalf("expected HeadersFrame; got %T %v", frame, frame)
 
417
        }
 
418
        if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 
419
                t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 
420
        }
 
421
        frame, err = framer.ReadFrame()
 
422
        if err != nil {
 
423
                t.Fatal("ReadFrame (SYN_STREAM):", err, buffer.Bytes())
 
424
        }
 
425
        parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
 
426
        if !ok {
 
427
                t.Fatalf("expected SynStreamFrame; got %T %v", frame, frame)
 
428
        }
 
429
        if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 
430
                t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 
431
        }
 
432
}
 
433
 
 
434
func TestMultipleSPDYFrames(t *testing.T) {
 
435
        // Initialize the framers.
 
436
        pr1, pw1 := io.Pipe()
 
437
        pr2, pw2 := io.Pipe()
 
438
        writer, err := NewFramer(pw1, pr2)
 
439
        if err != nil {
 
440
                t.Fatal("Failed to create writer:", err)
 
441
        }
 
442
        reader, err := NewFramer(pw2, pr1)
 
443
        if err != nil {
 
444
                t.Fatal("Failed to create reader:", err)
 
445
        }
 
446
 
 
447
        // Set up the frames we're actually transferring.
 
448
        headersFrame := HeadersFrame{
 
449
                CFHeader: ControlFrameHeader{
 
450
                        version:   Version,
 
451
                        frameType: TypeHeaders,
 
452
                },
 
453
                StreamId: 2,
 
454
                Headers: http.Header{
 
455
                        "Url":     []string{"http://www.google.com/"},
 
456
                        "Method":  []string{"get"},
 
457
                        "Version": []string{"http/1.1"},
 
458
                },
 
459
        }
 
460
        synStreamFrame := SynStreamFrame{
 
461
                CFHeader: ControlFrameHeader{
 
462
                        version:   Version,
 
463
                        frameType: TypeSynStream,
 
464
                },
 
465
                StreamId: 2,
 
466
                Headers: http.Header{
 
467
                        "Url":     []string{"http://www.google.com/"},
 
468
                        "Method":  []string{"get"},
 
469
                        "Version": []string{"http/1.1"},
 
470
                },
 
471
        }
 
472
 
 
473
        // Start the goroutines to write the frames.
 
474
        go func() {
 
475
                if err := writer.WriteFrame(&headersFrame); err != nil {
 
476
                        t.Fatal("WriteFrame (HEADERS): ", err)
 
477
                }
 
478
                if err := writer.WriteFrame(&synStreamFrame); err != nil {
 
479
                        t.Fatal("WriteFrame (SYN_STREAM): ", err)
 
480
                }
 
481
        }()
 
482
 
 
483
        // Read the frames and verify they look as expected.
 
484
        frame, err := reader.ReadFrame()
 
485
        if err != nil {
 
486
                t.Fatal("ReadFrame (HEADERS): ", err)
 
487
        }
 
488
        parsedHeadersFrame, ok := frame.(*HeadersFrame)
 
489
        if !ok {
 
490
                t.Fatal("Parsed incorrect frame type:", frame)
 
491
        }
 
492
        if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
 
493
                t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
 
494
        }
 
495
        frame, err = reader.ReadFrame()
 
496
        if err != nil {
 
497
                t.Fatal("ReadFrame (SYN_STREAM):", err)
 
498
        }
 
499
        parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
 
500
        if !ok {
 
501
                t.Fatal("Parsed incorrect frame type.")
 
502
        }
 
503
        if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
 
504
                t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
 
505
        }
 
506
}
 
507
 
 
508
func TestReadMalformedZlibHeader(t *testing.T) {
 
509
        // These were constructed by corrupting the first byte of the zlib
 
510
        // header after writing.
 
511
        malformedStructs := map[string]string{
 
512
                "SynStreamFrame": "gAIAAQAAABgAAAACAAAAAAAAF/nfolGyYmAAAAAA//8=",
 
513
                "SynReplyFrame":  "gAIAAgAAABQAAAACAAAX+d+iUbJiYAAAAAD//w==",
 
514
                "HeadersFrame":   "gAIACAAAABQAAAACAAAX+d+iUbJiYAAAAAD//w==",
 
515
        }
 
516
        for name, bad := range malformedStructs {
 
517
                b, err := base64.StdEncoding.DecodeString(bad)
 
518
                if err != nil {
 
519
                        t.Errorf("Unable to decode base64 encoded frame %s: %v", name, err)
 
520
                }
 
521
                buf := bytes.NewBuffer(b)
 
522
                reader, err := NewFramer(buf, buf)
 
523
                if err != nil {
 
524
                        t.Fatalf("NewFramer: %v", err)
 
525
                }
 
526
                _, err = reader.ReadFrame()
 
527
                if err != zlib.ErrHeader {
 
528
                        t.Errorf("Frame %s, expected: %#v, actual: %#v", name, zlib.ErrHeader, err)
 
529
                }
 
530
        }
 
531
}
 
532
 
 
533
type zeroStream struct {
 
534
        frame   Frame
 
535
        encoded string
 
536
}
 
537
 
 
538
var streamIdZeroFrames = map[string]zeroStream{
 
539
        "SynStreamFrame": {
 
540
                &SynStreamFrame{StreamId: 0},
 
541
                "gAIAAQAAABgAAAAAAAAAAAAAePnfolGyYmAAAAAA//8=",
 
542
        },
 
543
        "SynReplyFrame": {
 
544
                &SynReplyFrame{StreamId: 0},
 
545
                "gAIAAgAAABQAAAAAAAB4+d+iUbJiYAAAAAD//w==",
 
546
        },
 
547
        "RstStreamFrame": {
 
548
                &RstStreamFrame{StreamId: 0},
 
549
                "gAIAAwAAAAgAAAAAAAAAAA==",
 
550
        },
 
551
        "HeadersFrame": {
 
552
                &HeadersFrame{StreamId: 0},
 
553
                "gAIACAAAABQAAAAAAAB4+d+iUbJiYAAAAAD//w==",
 
554
        },
 
555
        "DataFrame": {
 
556
                &DataFrame{StreamId: 0},
 
557
                "AAAAAAAAAAA=",
 
558
        },
 
559
        "PingFrame": {
 
560
                &PingFrame{Id: 0},
 
561
                "gAIABgAAAAQAAAAA",
 
562
        },
 
563
}
 
564
 
 
565
func TestNoZeroStreamId(t *testing.T) {
 
566
        for name, f := range streamIdZeroFrames {
 
567
                b, err := base64.StdEncoding.DecodeString(f.encoded)
 
568
                if err != nil {
 
569
                        t.Errorf("Unable to decode base64 encoded frame %s: %v", f, err)
 
570
                        continue
 
571
                }
 
572
                framer, err := NewFramer(ioutil.Discard, bytes.NewReader(b))
 
573
                if err != nil {
 
574
                        t.Fatalf("NewFramer: %v", err)
 
575
                }
 
576
                err = framer.WriteFrame(f.frame)
 
577
                checkZeroStreamId(t, name, "WriteFrame", err)
 
578
 
 
579
                _, err = framer.ReadFrame()
 
580
                checkZeroStreamId(t, name, "ReadFrame", err)
 
581
        }
 
582
}
 
583
 
 
584
func checkZeroStreamId(t *testing.T, frame string, method string, err error) {
 
585
        if err == nil {
 
586
                t.Errorf("%s ZeroStreamId, no error on %s", method, frame)
 
587
                return
 
588
        }
 
589
        eerr, ok := err.(*Error)
 
590
        if !ok || eerr.Err != ZeroStreamId {
 
591
                t.Errorf("%s ZeroStreamId, incorrect error %#v, frame %s", method, eerr, frame)
 
592
        }
 
593
}