Skip to content

Commit 4abc63d

Browse files
briansorahanbriansorahan
committedNov 25, 2016
deduplicate and simplify code
·
v0.11.1v0.9.0
1 parent 8025a9d commit 4abc63d

File tree

5 files changed

+255
-154
lines changed

5 files changed

+255
-154
lines changed
 

‎argument.go

+31-16
Original file line numberDiff line numberDiff line change
@@ -51,17 +51,9 @@ func ReadArguments(typetags, data []byte) ([]Argument, error) {
5151
func ReadArgument(tt byte, data []byte) (Argument, int64, error) {
5252
switch tt {
5353
case TypetagInt:
54-
var val int32
55-
if err := binary.Read(bytes.NewReader(data), byteOrder, &val); err != nil {
56-
return nil, 0, errors.Wrap(err, "read int argument")
57-
}
58-
return Int(val), 4, nil
54+
return ReadIntFrom(data)
5955
case TypetagFloat:
60-
var val float32
61-
if err := binary.Read(bytes.NewReader(data), byteOrder, &val); err != nil {
62-
return nil, 0, errors.Wrap(err, "read float argument")
63-
}
64-
return Float(val), 4, nil
56+
return ReadFloatFrom(data)
6557
case TypetagTrue:
6658
return Bool(true), 0, nil
6759
case TypetagFalse:
@@ -70,12 +62,7 @@ func ReadArgument(tt byte, data []byte) (Argument, int64, error) {
7062
s, idx := ReadString(data)
7163
return String(s), idx, nil
7264
case TypetagBlob:
73-
var length int32
74-
if err := binary.Read(bytes.NewReader(data), byteOrder, &length); err != nil {
75-
return nil, 0, errors.Wrap(err, "read blob argument")
76-
}
77-
b, bl := ReadBlob(length, data[4:])
78-
return Blob(b), bl + 4, nil
65+
return ReadBlobFrom(data)
7966
default:
8067
return nil, 0, errors.Wrapf(ErrInvalidTypeTag, "typetag %q", string(tt))
8168
}
@@ -84,6 +71,15 @@ func ReadArgument(tt byte, data []byte) (Argument, int64, error) {
8471
// Int represents a 32-bit integer.
8572
type Int int32
8673

74+
// ReadIntFrom reads a 32-bit integer from a byte slice.
75+
func ReadIntFrom(data []byte) (Argument, int64, error) {
76+
var i Int
77+
if err := binary.Read(bytes.NewReader(data), byteOrder, &i); err != nil {
78+
return nil, 0, errors.Wrap(err, "read int argument")
79+
}
80+
return i, 4, nil
81+
}
82+
8783
// Bytes converts the arg to a byte slice suitable for adding to the binary representation of an OSC message.
8884
func (i Int) Bytes() []byte {
8985
return []byte{
@@ -133,6 +129,15 @@ func (i Int) WriteTo(w io.Writer) (int64, error) {
133129
// Float represents a 32-bit float.
134130
type Float float32
135131

132+
// ReadFloatFrom reads a 32-bit float from a byte slice.
133+
func ReadFloatFrom(data []byte) (Argument, int64, error) {
134+
var f Float
135+
if err := binary.Read(bytes.NewReader(data), byteOrder, &f); err != nil {
136+
return nil, 0, errors.Wrap(err, "read float argument")
137+
}
138+
return f, 4, nil
139+
}
140+
136141
// Bytes converts the arg to a byte slice suitable for adding to the binary representation of an OSC message.
137142
func (f Float) Bytes() []byte {
138143
var (
@@ -274,6 +279,16 @@ func (s String) WriteTo(w io.Writer) (int64, error) {
274279
// Blob is a slice of bytes.
275280
type Blob []byte
276281

282+
// ReadBlobFrom reads a binary blob from the provided data.
283+
func ReadBlobFrom(data []byte) (Argument, int64, error) {
284+
var length int32
285+
if err := binary.Read(bytes.NewReader(data), byteOrder, &length); err != nil {
286+
return nil, 0, errors.Wrap(err, "read blob argument")
287+
}
288+
b, bl := ReadBlob(length, data[4:])
289+
return Blob(b), bl + 4, nil
290+
}
291+
277292
// Bytes converts the arg to a byte slice suitable for adding to the binary representation of an OSC message.
278293
func (b Blob) Bytes() []byte {
279294
return Pad(bytes.Join([][]byte{

‎argument_test.go

+182-59
Original file line numberDiff line numberDiff line change
@@ -9,113 +9,193 @@ import (
99
"github.com/pkg/errors"
1010
)
1111

12-
func TestInt(t *testing.T) {
12+
type equalTest struct {
13+
arg Argument
14+
equal []Argument
15+
notEqual []Argument
16+
}
17+
18+
func (e equalTest) run(t *testing.T) {
19+
for i, eq := range e.equal {
20+
if !e.arg.Equal(eq) {
21+
t.Fatalf("equals[%d] expected %s to equal %s", i, e.arg, eq)
22+
}
23+
}
24+
for i, ne := range e.notEqual {
25+
if e.arg.Equal(ne) {
26+
t.Fatalf("notEquals[%d] expected %s to not equal %s", i, e.arg, ne)
27+
}
28+
}
29+
}
30+
31+
func TestIntBytes(t *testing.T) {
32+
for _, testcase := range []struct {
33+
Int Int
34+
Expected []byte
35+
}{
36+
{
37+
Int: Int(1),
38+
Expected: []byte{0, 0, 0, 1},
39+
},
40+
{
41+
Int: Int(256),
42+
Expected: []byte{0, 0, 1, 0},
43+
},
44+
} {
45+
if expected, got := testcase.Expected, testcase.Int.Bytes(); !bytes.Equal(expected, got) {
46+
t.Fatalf("expected %q, got %q", expected, got)
47+
}
48+
}
49+
}
50+
51+
func TestIntEqual(t *testing.T) {
52+
equalTest{
53+
arg: Int(0),
54+
equal: []Argument{Int(0)},
55+
notEqual: []Argument{Int(2), String("Foo")},
56+
}.run(t)
57+
}
58+
59+
func TestIntReadInt32(t *testing.T) {
1360
arg := Int(0)
1461
i, err := arg.ReadInt32()
1562
if err != nil {
1663
t.Fatal(err)
1764
}
18-
if other := Int(0); !arg.Equal(other) {
19-
t.Fatalf("expected %s to equal %s", arg, other)
20-
}
21-
if other := Int(2); arg.Equal(other) {
22-
t.Fatalf("expected %s to not equal %s", arg, other)
23-
}
24-
if other := String("foo"); arg.Equal(other) {
25-
t.Fatalf("expected %s to not equal %s", arg, other)
26-
}
2765
if expected, got := int32(0), i; expected != got {
2866
t.Fatalf("expected %d, got %d", expected, got)
2967
}
30-
if _, err := arg.ReadFloat32(); err != ErrInvalidTypeTag {
68+
}
69+
70+
func TestIntReadOther(t *testing.T) {
71+
i := Int(0)
72+
if _, err := i.ReadFloat32(); err != ErrInvalidTypeTag {
3173
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
3274
}
33-
if _, err := arg.ReadBool(); err != ErrInvalidTypeTag {
75+
if _, err := i.ReadBool(); err != ErrInvalidTypeTag {
3476
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
3577
}
36-
if _, err := arg.ReadString(); err != ErrInvalidTypeTag {
78+
if _, err := i.ReadString(); err != ErrInvalidTypeTag {
3779
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
3880
}
39-
if _, err := arg.ReadBlob(); err != ErrInvalidTypeTag {
81+
if _, err := i.ReadBlob(); err != ErrInvalidTypeTag {
4082
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
4183
}
84+
}
85+
86+
func TestIntString(t *testing.T) {
87+
arg := Int(0)
4288
if expected, got := "Int(0)", arg.String(); expected != got {
4389
t.Fatalf("expected %s to equal %s", expected, got)
4490
}
91+
}
92+
93+
func TestIntTypetag(t *testing.T) {
94+
arg := Int(0)
4595
if expected, got := TypetagInt, arg.Typetag(); expected != got {
4696
t.Fatalf("expected %c, got %c", expected, got)
4797
}
98+
}
99+
100+
func TestIntWriteTo(t *testing.T) {
101+
arg := Int(0)
48102
if _, err := arg.WriteTo(ioutil.Discard); err != nil {
49103
t.Fatal(err)
50104
}
51105
}
52106

53-
func TestFloat(t *testing.T) {
54-
arg := Float(0)
107+
func TestFloatBytes(t *testing.T) {
55108
if expected, got := []byte{0x40, 0x48, 0xf5, 0xc3}, Float(3.14).Bytes(); !bytes.Equal(expected, got) {
56109
t.Fatalf("expected %x, got %x", expected, got)
57110
}
58-
if other := Float(0); !arg.Equal(other) {
59-
t.Fatalf("expected %s to equal %s", arg, other)
60-
}
61-
if other := Float(3.14); arg.Equal(other) {
62-
t.Fatalf("expected %s to not equal %s", arg, other)
63-
}
64-
if other := String("foo"); arg.Equal(other) {
65-
t.Fatalf("expected %s to not equal %s", arg, other)
66-
}
111+
}
67112

113+
func TestFloatEqual(t *testing.T) {
114+
equalTest{
115+
arg: Float(0),
116+
equal: []Argument{Float(0)},
117+
notEqual: []Argument{Float(3.14), String("foo")},
118+
}.run(t)
119+
}
120+
121+
func TestFloatReadFloat(t *testing.T) {
122+
arg := Float(0)
68123
f, err := arg.ReadFloat32()
69124
if err != nil {
70125
t.Fatal(err)
71126
}
72127
if expected, got := float32(0), f; expected != got {
73128
t.Fatalf("expected %f, got %f", expected, got)
74129
}
130+
}
75131

76-
if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
132+
func TestFloatReadOther(t *testing.T) {
133+
f := Float(0)
134+
if _, err := f.ReadInt32(); err != ErrInvalidTypeTag {
77135
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
78136
}
79-
if _, err := arg.ReadBool(); err != ErrInvalidTypeTag {
137+
if _, err := f.ReadBool(); err != ErrInvalidTypeTag {
80138
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
81139
}
82-
if _, err := arg.ReadString(); err != ErrInvalidTypeTag {
140+
if _, err := f.ReadString(); err != ErrInvalidTypeTag {
83141
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
84142
}
85-
if _, err := arg.ReadBlob(); err != ErrInvalidTypeTag {
143+
if _, err := f.ReadBlob(); err != ErrInvalidTypeTag {
86144
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
87145
}
146+
}
147+
148+
func TestFloatString(t *testing.T) {
149+
arg := Float(0)
88150
if expected, got := "Float(0.000000)", arg.String(); expected != got {
89151
t.Fatalf("expected %s to equal %s", expected, got)
90152
}
153+
}
154+
155+
func TestFloatTypetag(t *testing.T) {
156+
arg := Float(0)
91157
if expected, got := TypetagFloat, arg.Typetag(); expected != got {
92158
t.Fatalf("expected %c, got %c", expected, got)
93159
}
160+
}
161+
162+
func TestFloatWriteTo(t *testing.T) {
163+
arg := Float(0)
94164
if _, err := arg.WriteTo(ioutil.Discard); err != nil {
95165
t.Fatal(err)
96166
}
97167
}
98168

99-
func TestBool(t *testing.T) {
169+
func TestBoolBytes(t *testing.T) {
100170
arg := Bool(false)
101171
if expected, got := []byte{}, arg.Bytes(); !bytes.Equal(expected, got) {
102172
t.Fatalf("expected %x, got %x", expected, got)
103173
}
104-
if other := Bool(false); !arg.Equal(other) {
105-
t.Fatalf("expected %s to equal %s", arg, other)
106-
}
174+
}
175+
176+
func TestBoolEqual(t *testing.T) {
177+
arg := Bool(false)
107178
if other := Int(3); arg.Equal(other) {
108179
t.Fatalf("expected %s to not equal %s", arg, other)
109180
}
181+
if other := Bool(false); !arg.Equal(other) {
182+
t.Fatalf("expected %s to equal %s", arg, other)
183+
}
184+
}
110185

186+
func TestBoolReadBool(t *testing.T) {
187+
arg := Bool(false)
111188
b, err := arg.ReadBool()
112189
if err != nil {
113190
t.Fatal(err)
114191
}
115192
if expected, got := false, b; expected != got {
116193
t.Fatalf("expected %t, got %t", expected, got)
117194
}
195+
}
118196

197+
func TestBoolReadOther(t *testing.T) {
198+
arg := Bool(false)
119199
if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
120200
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
121201
}
@@ -128,43 +208,63 @@ func TestBool(t *testing.T) {
128208
if _, err := arg.ReadBlob(); err != ErrInvalidTypeTag {
129209
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
130210
}
211+
}
212+
213+
func TestBoolString(t *testing.T) {
214+
arg := Bool(false)
131215
if expected, got := "Bool(false)", arg.String(); expected != got {
132216
t.Fatalf("expected %s to equal %s", expected, got)
133217
}
218+
}
219+
220+
func TestBoolTypetag(t *testing.T) {
221+
arg := Bool(false)
134222
if expected, got := TypetagFalse, arg.Typetag(); expected != got {
135223
t.Fatalf("expected %c, got %c", expected, got)
136224
}
137-
138225
argTrue := Bool(true)
139226
if expected, got := TypetagTrue, argTrue.Typetag(); expected != got {
140227
t.Fatalf("expected %c, got %c", expected, got)
141228
}
229+
}
142230

231+
func TestBoolWriteTo(t *testing.T) {
232+
arg := Bool(false)
143233
if _, err := arg.WriteTo(ioutil.Discard); err != nil {
144234
t.Fatal(err)
145235
}
146236
}
147237

148-
func TestString(t *testing.T) {
238+
func TestStringBytes(t *testing.T) {
149239
arg := String("foo")
150240
if expected, got := []byte{'f', 'o', 'o', 0}, arg.Bytes(); !bytes.Equal(expected, got) {
151241
t.Fatalf("expected %x, got %x", expected, got)
152242
}
243+
}
244+
245+
func TestStringEqual(t *testing.T) {
246+
arg := String("foo")
153247
if other := String("foo"); !arg.Equal(other) {
154248
t.Fatalf("expected %s to equal %s", arg, other)
155249
}
156250
if other := Int(4); arg.Equal(other) {
157251
t.Fatalf("expected %s to not equal %s", arg, other)
158252
}
253+
}
159254

255+
func TestStringReadString(t *testing.T) {
256+
arg := String("foo")
160257
s, err := arg.ReadString()
161258
if err != nil {
162259
t.Fatal(err)
163260
}
164261
if expected, got := "foo", s; expected != got {
165262
t.Fatalf("expected %s, got %s", expected, got)
166263
}
264+
}
167265

266+
func TestStringReadOther(t *testing.T) {
267+
arg := String("foo")
168268
if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
169269
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
170270
}
@@ -177,23 +277,38 @@ func TestString(t *testing.T) {
177277
if _, err := arg.ReadBlob(); err != ErrInvalidTypeTag {
178278
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
179279
}
280+
}
281+
282+
func TestStringString(t *testing.T) {
283+
arg := String("foo")
180284
if expected, got := "foo", arg.String(); expected != got {
181285
t.Fatalf("expected %s to equal %s", expected, got)
182286
}
287+
}
288+
289+
func TestStringTypetag(t *testing.T) {
290+
arg := String("foo")
183291
if expected, got := TypetagString, arg.Typetag(); expected != got {
184292
t.Fatalf("expected %c, got %c", expected, got)
185293
}
294+
}
295+
296+
func TestStringWriteTo(t *testing.T) {
297+
arg := String("foo")
186298
if _, err := arg.WriteTo(ioutil.Discard); err != nil {
187299
t.Fatal(err)
188300
}
189301
}
190302

191-
func TestBlob(t *testing.T) {
303+
func TestBlobBytes(t *testing.T) {
192304
arg := Blob([]byte{'f', 'o', 'o'})
193-
b, err := arg.ReadBlob()
194-
if err != nil {
195-
t.Fatal(err)
305+
if expected, got := []byte{0, 0, 0, 3, 'f', 'o', 'o', 0}, arg.Bytes(); !bytes.Equal(expected, got) {
306+
t.Fatalf("expected %q, got %q", expected, got)
196307
}
308+
}
309+
310+
func TestBlobEqual(t *testing.T) {
311+
arg := Blob([]byte{'f', 'o', 'o'})
197312
if other := Blob([]byte{'f', 'o', 'o'}); !arg.Equal(other) {
198313
t.Fatalf("expected %s to equal %s", arg, other)
199314
}
@@ -203,9 +318,21 @@ func TestBlob(t *testing.T) {
203318
if other := String("bar"); arg.Equal(other) {
204319
t.Fatalf("expected %s to not equal %s", arg, other)
205320
}
321+
}
322+
323+
func TestBlobReadBlob(t *testing.T) {
324+
arg := Blob([]byte{'f', 'o', 'o'})
325+
b, err := arg.ReadBlob()
326+
if err != nil {
327+
t.Fatal(err)
328+
}
206329
if expected, got := []byte{'f', 'o', 'o'}, b; !bytes.Equal(expected, got) {
207330
t.Fatalf("expected %q, got %q", expected, got)
208331
}
332+
}
333+
334+
func TestBlobReadOther(t *testing.T) {
335+
arg := Blob([]byte{'f', 'o', 'o'})
209336
if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
210337
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
211338
}
@@ -218,12 +345,28 @@ func TestBlob(t *testing.T) {
218345
if _, err := arg.ReadString(); err != ErrInvalidTypeTag {
219346
t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
220347
}
348+
}
349+
350+
func TestBlobString(t *testing.T) {
351+
arg := Blob([]byte{'f', 'o', 'o'})
352+
b, err := arg.ReadBlob()
353+
if err != nil {
354+
t.Fatal(err)
355+
}
221356
if expected, got := base64.StdEncoding.EncodeToString(b), arg.String(); expected != got {
222357
t.Fatalf("expected %s, got %s", expected, got)
223358
}
359+
}
360+
361+
func TestBlobTypetag(t *testing.T) {
362+
arg := Blob([]byte{'f', 'o', 'o'})
224363
if expected, got := TypetagBlob, arg.Typetag(); expected != got {
225364
t.Fatalf("expected %c, got %c", expected, got)
226365
}
366+
}
367+
368+
func TestBlobWriteTo(t *testing.T) {
369+
arg := Blob([]byte{'f', 'o', 'o'})
227370
if _, err := arg.WriteTo(ioutil.Discard); err != nil {
228371
t.Fatal(err)
229372
}
@@ -359,23 +502,3 @@ func TestReadArguments(t *testing.T) {
359502
}
360503
}
361504
}
362-
363-
func TestIntBytes(t *testing.T) {
364-
for _, testcase := range []struct {
365-
Int Int
366-
Expected []byte
367-
}{
368-
{
369-
Int: Int(1),
370-
Expected: []byte{0, 0, 0, 1},
371-
},
372-
{
373-
Int: Int(256),
374-
Expected: []byte{0, 0, 1, 0},
375-
},
376-
} {
377-
if expected, got := testcase.Expected, testcase.Int.Bytes(); !bytes.Equal(expected, got) {
378-
t.Fatalf("expected %q, got %q", expected, got)
379-
}
380-
}
381-
}

‎conn.go

-3
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,8 @@ const (
1212

1313
// Common errors.
1414
var (
15-
errBundle = errors.New("message is a bundle")
1615
ErrNilDispatcher = errors.New("nil dispatcher")
1716
ErrPrematureClose = errors.New("server cannot be closed before calling Listen")
18-
networkTCP = "tcp"
19-
networkUDP = "udp"
2017
)
2118

2219
// Conn defines the methods

‎tcp.go

-9
This file was deleted.

‎udp_test.go

+42-67
Original file line numberDiff line numberDiff line change
@@ -41,9 +41,14 @@ func TestListenUDP(t *testing.T) {
4141
}
4242
}
4343

44-
func TestUDPConnSend_OK(t *testing.T) {
45-
errChan := make(chan error)
46-
44+
// testUDPServer creates a server listening on an ephemeral port,
45+
// initializes a connection to that server, and returns the connection
46+
// and a channel that emits the error returned from the server's
47+
// Serve method.
48+
// For clients that are interested in closing the server with an OSC
49+
// message, a method is automatically added to the provided dispatcher
50+
// at the "/server/close" address that closes the server.
51+
func testUDPServer(t *testing.T, dispatcher Dispatcher) (*UDPConn, chan error) {
4752
// Setup the server.
4853
laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
4954
if err != nil {
@@ -53,15 +58,19 @@ func TestUDPConnSend_OK(t *testing.T) {
5358
if err != nil {
5459
t.Fatal(err)
5560
}
61+
if dispatcher == nil {
62+
dispatcher = Dispatcher{}
63+
}
64+
dispatcher["/server/close"] = func(msg Message) error {
65+
return server.Close()
66+
}
67+
errChan := make(chan error)
68+
5669
go func() {
57-
errChan <- server.Serve(map[string]Method{
58-
"/close": func(msg Message) error {
59-
return server.Close()
60-
},
61-
})
70+
errChan <- server.Serve(dispatcher)
6271
}()
6372

64-
// Setup the client.
73+
// Send a message with a bad address.
6574
raddr, err := net.ResolveUDPAddr("udp", server.LocalAddr().String())
6675
if err != nil {
6776
t.Fatal(err)
@@ -70,6 +79,11 @@ func TestUDPConnSend_OK(t *testing.T) {
7079
if err != nil {
7180
t.Fatal(err)
7281
}
82+
return conn, errChan
83+
}
84+
85+
func TestUDPConnSend_OK(t *testing.T) {
86+
conn, errChan := testUDPServer(t, nil)
7387
if err := conn.Send(Message{Address: "/close"}); err != nil {
7488
t.Fatal(err)
7589
}
@@ -154,68 +168,29 @@ func (bp badPacket) Bytes() []byte {
154168
)
155169
}
156170

157-
func testUDPServer(t *testing.T, dispatcher Dispatcher) (*UDPConn, chan error) {
158-
// Setup the server.
159-
laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
160-
if err != nil {
161-
t.Fatal(err)
162-
}
163-
server, err := ListenUDP("udp", laddr)
164-
if err != nil {
165-
t.Fatal(err)
166-
}
167-
errChan := make(chan error)
168-
go func() {
169-
errChan <- server.Serve(dispatcher)
170-
}()
171-
172-
// Send a message with a bad address.
173-
raddr, err := net.ResolveUDPAddr("udp", server.LocalAddr().String())
174-
if err != nil {
175-
t.Fatal(err)
176-
}
177-
conn, err := DialUDP("udp", nil, raddr)
178-
if err != nil {
179-
t.Fatal(err)
180-
}
181-
return conn, errChan
182-
}
183-
184171
func TestUDPConnServe_BadInboundAddr(t *testing.T) {
185-
// Send a message with a bad address.
186-
conn, errChan := testUDPServer(t, Dispatcher{
187-
"/foo": func(msg Message) error {
188-
return nil
189-
},
190-
})
191-
if err := conn.Send(Message{Address: "/["}); err != nil {
192-
t.Fatal(err)
193-
}
194-
if err := <-errChan; err == nil {
195-
t.Fatal("expected error, got nil")
196-
}
197-
}
198-
199-
func TestUDPConnServe_BadInboundLeadingChar(t *testing.T) {
200-
conn, errChan := testUDPServer(t, Dispatcher{
201-
"/foo": func(msg Message) error {
202-
return nil
203-
},
204-
})
205-
if err := conn.Send(Message{Address: "["}); err != nil {
206-
t.Fatal(err)
207-
}
208-
if err := <-errChan; err == nil {
209-
t.Fatal("expected error, got nil")
172+
for i, packet := range []Packet{
173+
Message{Address: "/["},
174+
Message{Address: "["},
175+
badPacket{},
176+
} {
177+
// Send a message with a bad address.
178+
conn, errChan := testUDPServer(t, Dispatcher{
179+
"/foo": func(msg Message) error {
180+
return nil
181+
},
182+
})
183+
if err := conn.Send(packet); err != nil {
184+
t.Fatal(err)
185+
}
186+
if err := <-errChan; err == nil {
187+
t.Fatalf("(packet %d) expected error, got nil", i)
188+
}
210189
}
211190
}
212191

213-
func TestUDPConnServe_BadInboundTypetag(t *testing.T) {
214-
conn, errChan := testUDPServer(t, Dispatcher{
215-
"/foo": func(msg Message) error {
216-
return nil
217-
},
218-
})
192+
func TestUDPConnSendTo(t *testing.T) {
193+
conn, errChan := testUDPServer(t, nil)
219194
laddr2, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
220195
if err != nil {
221196
t.Fatal(err)

0 commit comments

Comments
 (0)
Please sign in to comment.