simplify udp example. update readme.

Author: briansorahan

README.md

@@ -12,13 +12,13 @@ go install github.com/scgolang/osc
 
 ## Usage
 
-### Server
+See the [ping pong example](https://godoc.org/github.com/scgolang/osc#example-UDPConn--Pingpong).
 
-This is a fully functioning OSC server that uses UDP.
+## Contributing
 
-```go
-package main
+This package aims to be high quality and completely compliant with the [OSC 1.0 Spec](http://opensoundcontrol.org/spec-1_0).
 
-func main() {
-}
-```
+If there is anything missing or this package does not satisfy your use case please open an issue with a detailed description
+of what you are doing and we will try to address it as quickly as possible.
+
+If you wish to contribute code, please write tests that cover _all_ your code.

udp_example_test.go

@@ -1,6 +1,7 @@
 package osc
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"net"
@@ -21,22 +22,7 @@ func ExampleUDPConn_pingpong() {
 	}
 
 	// Run the server in a new goroutine.
-	go func() {
-		errChan <- server.Serve(Dispatcher{
-			"/ping": func(msg Message) error {
-				fmt.Println("Server received ping.")
-				return server.SendTo(msg.Sender, Message{Address: "/pong"})
-			},
-			"/close": func(msg Message) error {
-				if err := server.SendTo(msg.Sender, Message{Address: "/close"}); err != nil {
-					_ = server.Close()
-					return err
-				}
-				fmt.Println("Server closing.")
-				return server.Close()
-			},
-		})
-	}()
+	go serverDispatch(server, errChan)
 
 	// Setup the client.
 	raddr, err := net.ResolveUDPAddr("udp", server.LocalAddr().String())
@@ -48,59 +34,96 @@ func ExampleUDPConn_pingpong() {
 		log.Fatal(err)
 	}
 
-	// Clients are also servers!
 	var (
 		pongChan        = make(chan struct{})
 		clientCloseChan = make(chan struct{})
 	)
-
-	go func() {
-		errChan <- client.Serve(Dispatcher{
-			"/pong": func(msg Message) error {
-				fmt.Println("Client received pong.")
-				close(pongChan)
-				return nil
-			},
-			"/close": func(msg Message) error {
-				fmt.Println("Client closing.")
-				close(clientCloseChan)
-				return client.Close()
-			},
-		})
-	}()
+	// Clients are also servers!
+	go clientDispatch(client, errChan, pongChan, clientCloseChan)
 
 	// Send the ping message, wait for the pong, then close both connections.
 	if err := client.Send(Message{Address: "/ping"}); err != nil {
 		log.Fatal(err)
 	}
+	if err := waitPong(pongChan, errChan); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := client.Send(Message{Address: "/close"}); err != nil {
+		log.Fatal(err)
+	}
+	if err := waitErr(errChan); err != nil {
+		log.Fatal(err)
+	}
+	if err := waitClose(clientCloseChan, errChan); err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// Server received ping.
+	// Client received pong.
+	// Server closing.
+	// Client closing.
+}
+
+func serverDispatch(server *UDPConn, errChan chan error) {
+	errChan <- server.Serve(Dispatcher{
+		"/ping": func(msg Message) error {
+			fmt.Println("Server received ping.")
+			return server.SendTo(msg.Sender, Message{Address: "/pong"})
+		},
+		"/close": func(msg Message) error {
+			if err := server.SendTo(msg.Sender, Message{Address: "/close"}); err != nil {
+				_ = server.Close()
+				return err
+			}
+			fmt.Println("Server closing.")
+			return server.Close()
+		},
+	})
+}
+
+func clientDispatch(client *UDPConn, errChan chan error, pongChan chan struct{}, closeChan chan struct{}) {
+	errChan <- client.Serve(Dispatcher{
+		"/pong": func(msg Message) error {
+			fmt.Println("Client received pong.")
+			close(pongChan)
+			return nil
+		},
+		"/close": func(msg Message) error {
+			fmt.Println("Client closing.")
+			close(closeChan)
+			return client.Close()
+		},
+	})
+}
+
+func waitPong(pongChan chan struct{}, errChan chan error) error {
 	select {
 	case <-time.After(2 * time.Second):
-		log.Fatal("timeout")
+		return errors.New("timeout")
 	case err := <-errChan:
 		if err != nil {
-			log.Fatal(err)
+			return err
 		}
 	case <-pongChan:
 	}
-	if err := client.Send(Message{Address: "/close"}); err != nil {
-		log.Fatal(err)
-	}
+	return nil
+}
+
+func waitErr(errChan chan error) error {
 	select {
 	case <-time.After(2 * time.Second):
-		log.Fatal("timeout")
+		return errors.New("timeout")
 	case err := <-errChan:
-		if err != nil {
-			log.Fatal(err)
-		}
+		return err
 	}
+}
+
+func waitClose(closeChan chan struct{}, errChan chan error) error {
 	select {
 	case <-time.After(2 * time.Second):
-		log.Fatal("timeout")
-	case <-clientCloseChan:
+		return errors.New("timeout")
+	case <-closeChan:
 	}
-	// Output:
-	// Server received ping.
-	// Client received pong.
-	// Server closing.
-	// Client closing.
+	return nil
 }

udp_test.go

@@ -55,7 +55,8 @@ func TestDialUDPContext(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	ctxTimeout, _ := context.WithTimeout(c.Context(), 20*time.Millisecond)
+	ctxTimeout, cancel := context.WithTimeout(c.Context(), 20*time.Millisecond)
+	defer cancel()
 	c.SetContext(ctxTimeout)
 	if c.Context() != ctxTimeout {
 		t.Fatalf("expected %+v to be %+v", ctxTimeout, c.Context())
@@ -126,7 +127,8 @@ func TestUDPConnServe_ContextTimeout(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	timeoutCtx, _ := context.WithTimeout(context.Background(), 20*time.Millisecond)
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
+	defer cancel()
 	server, err := ListenUDPContext(timeoutCtx, "udp", laddr)
 	if err != nil {
 		t.Fatal(err)