100% test coverage

Author: briansorahan

argument.go

@@ -31,6 +31,11 @@ type Argument interface {
 func ReadArguments(typetags, data []byte) ([]Argument, error) {
 	args := []Argument{}
 
+	// Strip off the prefix.
+	if len(typetags) > 0 && typetags[0] == TypetagPrefix {
+		typetags = typetags[1:]
+	}
+
 	for i, tt := range typetags {
 		arg, idx, err := ReadArgument(tt, data)
 		if err != nil {
@@ -72,7 +77,7 @@ func ReadArgument(tt byte, data []byte) (Argument, int64, error) {
 		b, bl := ReadBlob(length, data[4:])
 		return Blob(b), bl + 4, nil
 	default:
-		return nil, 0, ErrInvalidTypeTag
+		return nil, 0, errors.Wrapf(ErrInvalidTypeTag, "typetag %q", string(tt))
 	}
 }
 
@@ -227,7 +232,7 @@ type String string
 
 // Bytes converts the arg to a byte slice suitable for adding to the binary representation of an OSC message.
 func (s String) Bytes() []byte {
-	return OscString(string(s))
+	return ToBytes(string(s))
 }
 
 // Equal returns true if the argument equals the other one, false otherwise.
@@ -277,6 +282,7 @@ func (b Blob) Bytes() []byte {
 	}, []byte{}))
 }
 
+// Equal returns true if the argument equals the other one, false otherwise.
 func (b Blob) Equal(other Argument) bool {
 	if other.Typetag() != TypetagBlob {
 		return false
@@ -314,3 +320,6 @@ func (b Blob) WriteTo(w io.Writer) (int64, error) {
 	written, err := w.Write([]byte(b))
 	return int64(written), err
 }
+
+// Arguments is a slice of Argument.
+type Arguments []Argument

argument_test.go

@@ -52,9 +52,8 @@ func TestInt(t *testing.T) {
 
 func TestFloat(t *testing.T) {
 	arg := Float(0)
-	f, err := arg.ReadFloat32()
-	if err != nil {
-		t.Fatal(err)
+	if expected, got := []byte{0x40, 0x48, 0xf5, 0xc3}, Float(3.14).Bytes(); !bytes.Equal(expected, got) {
+		t.Fatalf("expected %x, got %x", expected, got)
 	}
 	if other := Float(0); !arg.Equal(other) {
 		t.Fatal("expected %s to equal %s", arg, other)
@@ -65,9 +64,15 @@ func TestFloat(t *testing.T) {
 	if other := String("foo"); arg.Equal(other) {
 		t.Fatal("expected %s to not equal %s", arg, other)
 	}
+
+	f, err := arg.ReadFloat32()
+	if err != nil {
+		t.Fatal(err)
+	}
 	if expected, got := float32(0), f; expected != got {
 		t.Fatalf("expected %f, got %f", expected, got)
 	}
+
 	if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
 		t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
 	}
@@ -93,19 +98,24 @@ func TestFloat(t *testing.T) {
 
 func TestBool(t *testing.T) {
 	arg := Bool(false)
-	b, err := arg.ReadBool()
-	if err != nil {
-		t.Fatal(err)
+	if expected, got := []byte{}, arg.Bytes(); !bytes.Equal(expected, got) {
+		t.Fatalf("expected %x, got %x", expected, got)
 	}
 	if other := Bool(false); !arg.Equal(other) {
 		t.Fatal("expected %s to equal %s", arg, other)
 	}
 	if other := Int(3); arg.Equal(other) {
 		t.Fatal("expected %s to not equal %s", arg, other)
 	}
+
+	b, err := arg.ReadBool()
+	if err != nil {
+		t.Fatal(err)
+	}
 	if expected, got := false, b; expected != got {
 		t.Fatalf("expected %f, got %f", expected, got)
 	}
+
 	if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
 		t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
 	}
@@ -137,19 +147,24 @@ func TestBool(t *testing.T) {
 
 func TestString(t *testing.T) {
 	arg := String("foo")
-	s, err := arg.ReadString()
-	if err != nil {
-		t.Fatal(err)
+	if expected, got := []byte{'f', 'o', 'o', 0}, arg.Bytes(); !bytes.Equal(expected, got) {
+		t.Fatalf("expected %x, got %x", expected, got)
 	}
 	if other := String("foo"); !arg.Equal(other) {
 		t.Fatalf("expected %s to equal %s", arg, other)
 	}
 	if other := Int(4); arg.Equal(other) {
 		t.Fatal("expected %s to not equal %s", arg, other)
 	}
+
+	s, err := arg.ReadString()
+	if err != nil {
+		t.Fatal(err)
+	}
 	if expected, got := "foo", s; expected != got {
 		t.Fatalf("expected %s, got %s", expected, got)
 	}
+
 	if _, err := arg.ReadInt32(); err != ErrInvalidTypeTag {
 		t.Fatalf("expected ErrInvalidTypeTag, got %+v", err)
 	}
@@ -267,7 +282,7 @@ func TestReadArgument(t *testing.T) {
 		},
 		{
 			Input:    Input{tt: 'Q'},
-			Expected: Output{Err: ErrInvalidTypeTag},
+			Expected: Output{Err: errors.Wrap(ErrInvalidTypeTag, `typetag "Q"`)},
 		},
 	} {
 		a, consumed, err := ReadArgument(testcase.Input.tt, testcase.Input.data)

bundle.go

@@ -3,7 +3,6 @@ package osc
 import (
 	"errors"
 	"net"
-	"time"
 )
 
 // Common errors.
@@ -21,16 +20,7 @@ type Bundle struct {
 	Sender  net.Addr
 }
 
-// NewBundle returns an OSC Bundle.
-func NewBundle(t time.Time, packets ...Packet) *Bundle {
-	return &Bundle{
-		Timetag: FromTime(t),
-		Packets: packets,
-	}
-}
-
-// Contents returns the contents of the bundle as a
-// slice of bytes.
-func (b *Bundle) Contents() ([]byte, error) {
-	return []byte{}, nil
+// Bytes returns the contents of the bundle as a slice of bytes.
+func (b Bundle) Bytes() []byte {
+	return []byte{}
 }

bundle_test.go

@@ -1,8 +1,13 @@
 package osc
 
 import (
+	"bytes"
 	"testing"
 )
 
 func TestBundle(t *testing.T) {
+	b := Bundle{}
+	if expected, got := []byte{}, b.Bytes(); !bytes.Equal(expected, got) {
+		t.Fatalf("expected %x, got %x", expected, got)
+	}
 }

dispatcher.go

@@ -13,8 +13,8 @@ type Method func(msg Message) error
 // Dispatcher dispatches OSC packets.
 type Dispatcher map[string]Method
 
-// DispatchMessage dispatches OSC message.
-func (d Dispatcher) DispatchMessage(msg Message) error {
+// Dispatch dispatches OSC message.
+func (d Dispatcher) Dispatch(msg Message) error {
 	for address, method := range d {
 		matched, err := msg.Match(address)
 		if err != nil {

dispatcher_test.go

@@ -5,14 +5,27 @@ import (
 	"testing"
 )
 
-func TestDispatchMessage(t *testing.T) {
+func TestDispatcher(t *testing.T) {
 	d := Dispatcher{
 		"/foo": func(msg Message) error {
 			return errors.New("foo error")
 		},
+		"/bar": func(msg Message) error {
+			return nil
+		},
 	}
 	msg := Message{Address: "/foo"}
-	if err := d.DispatchMessage(msg); err == nil {
+	if err := d.Dispatch(msg); err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	badMsg := Message{Address: "/["}
+	if err := d.Dispatch(badMsg); err == nil {
 		t.Fatal("expected error, got nil")
 	}
+	if err := d.Dispatch(Message{Address: "/bar"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := d.Dispatch(Message{Address: "/baz"}); err != nil {
+		t.Fatal(err)
+	}
 }

message.go

@@ -27,6 +27,22 @@ type Message struct {
 	Sender    net.Addr
 }
 
+// Equal returns true if the messages are equal, false otherwise.
+func (msg Message) Equal(other Message) bool {
+	if msg.Address != other.Address {
+		return false
+	}
+	if len(msg.Arguments) != len(other.Arguments) {
+		return false
+	}
+	for i, a := range msg.Arguments {
+		if !a.Equal(other.Arguments[i]) {
+			return false
+		}
+	}
+	return true
+}
+
 // Match returns true if the address of the OSC Message matches the given address.
 func (msg Message) Match(address string) (bool, error) {
 	// Verify same number of parts.
@@ -43,7 +59,7 @@ func (msg Message) Match(address string) (bool, error) {
 // Bytes returns the contents of the message as a slice of bytes.
 func (msg Message) Bytes() []byte {
 	b := [][]byte{
-		OscString(msg.Address),
+		ToBytes(msg.Address),
 		msg.Typetags(),
 	}
 	for _, a := range msg.Arguments {
@@ -63,7 +79,7 @@ func (msg Message) Typetags() []byte {
 }
 
 // WriteTo writes the Message to an io.Writer.
-func (msg Message) Print(w io.Writer) error {
+func (msg Message) WriteTo(w io.Writer) error {
 	if _, err := fmt.Fprintf(w, "%s%s", msg.Address, msg.Typetags()); err != nil {
 		return err
 	}
@@ -84,17 +100,14 @@ func ParseMessage(data []byte, sender net.Addr) (Message, error) {
 		Address: address,
 		Sender:  sender,
 	}
-
 	data = data[idx:]
-
 	typetags, idx := ReadString(data)
-
 	data = data[idx:]
 
 	// Read all arguments.
-	args, err := ReadArguments([]byte(typetags), data[idx:])
+	args, err := ReadArguments([]byte(typetags), data)
 	if err != nil {
-		return Message{}, err
+		return Message{}, errors.Wrap(err, "parse message")
 	}
 	msg.Arguments = args