@@ -60,7 +60,7 @@ const (

 // The watch event effect matrix defines the valid event sequences and what their effects are on

 // the state of the event queue.

 //

-// A watch event that produces an invalid sequence is dropped (but this should not happen).

+// A watch event that produces an invalid sequence results in a panic.

 var watchEventEffectMatrix = map[watch.EventType]map[watch.EventType]watchEventEffect{

 	watch.Added: {

 		watch.Modified: watchEventEffectCompress,

@@ -86,7 +86,7 @@ var watchEventCompressionMatrix = map[watch.EventType]map[watch.EventType]watch.

 }

 // handleEvent is called by Add, Update, and Delete to determine the effect

-// of an event of the queue, realize that effect, and update the underlying store

+// of an event of the queue, realize that effect, and update the underlying store.

 func (eq *EventQueue) handleEvent(id string, obj interface{}, newEventType watch.EventType) {

 	eq.lock.Lock()

 	defer eq.lock.Unlock()

@@ -127,8 +127,8 @@ func (eq *EventQueue) handleEvent(id string, obj interface{}, newEventType watch

 	}

 }

-// updateStore updates the stored value for the given id.  Notice that deletions are not handled

-// here - they are performed in Pop in order to provide the deleted value on watch.Deleted events.

+// updateStore updates the stored value for the given id.  Note that deletions are not handled

+// here; they are performed in Pop in order to provide the deleted value on watch.Deleted events.

 func (eq *EventQueue) updateStore(id string, obj interface{}, eventType watch.EventType) {

 	if eventType == watch.Deleted {

 		return

@@ -25,54 +25,38 @@ import (

 func TestEventQueue_basic(t *testing.T) {

 	q := NewEventQueue()

-	q.Add("boo", 2)

-	q.Add("foo", 10)

-	q.Add("bar", 1)

-	q.Update("foo", 11)

-	q.Update("foo", 13)

-	q.Delete("bar")

-	q.Add("zab", 30)

-

-	event, thing := q.Pop()

-

-	if thing != 2 {

-		t.Fatalf("expected %v, got %v", 2, thing)

-	}

-

-	if event != watch.Added {

-		t.Fatalf("expected %s, got %s", watch.Added, event)

-	}

-

-	q.Update("boo", 3)

-

-	event, thing = q.Pop()

-

-	if thing != 13 {

-		t.Fatalf("expected %v, got %v", 13, thing)

-	}

-

-	if event != watch.Added {

-		t.Fatalf("expected %s, got %s", watch.Added, event)

-	}

-

-	event, thing = q.Pop()

-

-	if thing != 30 {

-		t.Fatalf("expected %v, got %v", 30, thing)

-	}

-

-	if event != watch.Added {

-		t.Fatalf("expected %s, got %s", watch.Added, event)

-	}

-

-	event, thing = q.Pop()

-

-	if thing != 3 {

-		t.Fatalf("expected %v, got %v", 3, thing)

-	}

-

-	if event != watch.Modified {

-		t.Fatalf("expected %s, got %s", watch.Modified, event)

+	const amount = 500

+	go func() {

+		for i := 0; i < amount; i++ {

+			q.Add(string([]rune{'a', rune(i)}), i+1)

+		}

+	}()

+	go func() {

+		for u := uint(0); u < amount; u++ {

+			q.Add(string([]rune{'b', rune(u)}), u+1)

+		}

+	}()

+

+	lastInt := int(0)

+	lastUint := uint(0)

+	for i := 0; i < amount*2; i++ {

+		_, obj := q.Pop()

+

+		switch obj.(type) {

+		case int:

+			if obj.(int) <= lastInt {

+				t.Errorf("got %v (int) out of order, last was %v", obj, lastInt)

+			}

+			lastInt = obj.(int)

+		case uint:

+			if obj.(uint) <= lastUint {

+				t.Errorf("got %v (uint) out of order, last was %v", obj, lastUint)

+			} else {

+				lastUint = obj.(uint)

+			}

+		default:

+			t.Fatalf("unexpected type %#v", obj)

+		}

 	}

 }

@@ -9,10 +9,13 @@ import (

 	routeapi "github.com/openshift/origin/pkg/route/api"

 )

+// RouteRegistry provides an in-memory implementation of

+// the route.Registry interface.

 type RouteRegistry struct {

 	Routes *routeapi.RouteList

 }

+// NewRouteRegistry creates a new RouteRegistry.

 func NewRouteRegistry() *RouteRegistry {

 	return &RouteRegistry{}

 }

@@ -37,9 +37,9 @@ func TestHandleRoute(t *testing.T) {

 		"deleted":  {eventType: watch.Deleted, existing: true, aliasRemoved: true},

 	}

-	for name, c := range cases {

+	for name, tc := range cases {

 		existingFrontends := map[string]router.Frontend{}

-		if c.existing {

+		if tc.existing {

 			existingFrontends[testRouteServiceName] = router.Frontend{}

 		}

@@ -50,12 +50,12 @@ func TestHandleRoute(t *testing.T) {

 				panic("Unreachable")

 			},

 			NextRoute: func() (watch.EventType, *routeapi.Route) {

-				return c.eventType, &testRoute

+				return tc.eventType, &testRoute

 			},

 		}

 		expectedFrontends := 0

-		if c.frontendCreated {

+		if tc.frontendCreated {

 			expectedFrontends = 1

 		}

@@ -65,7 +65,7 @@ func TestHandleRoute(t *testing.T) {

 			t.Errorf("Case %v: Frontend should have been created", name)

 		}

-		if c.aliasAdded {

+		if tc.aliasAdded {

 			addedAlias, ok := testRouter.AddedAliases[testRouteHost]

 			if !ok {

 				t.Errorf("Case %v: An alias should have been added for %v", name, testRouteHost)

@@ -76,7 +76,7 @@ func TestHandleRoute(t *testing.T) {

 			}

 		}

-		if c.aliasRemoved {

+		if tc.aliasRemoved {

 			removedAlias, ok := testRouter.RemovedAliases[testRouteHost]

 			if !ok {

 				t.Errorf("Case %v: An alias should have been removed for %v", name, testRouteHost)

@@ -97,7 +97,7 @@ func TestHandleRoute(t *testing.T) {

 	}

 }

-func TestHandleEndpointsAdded(t *testing.T) {

+func TestHandleEndpoints(t *testing.T) {

 	var (

 		testEndpointsName = "testendpoints"

 		testEndpoints     = kapi.Endpoints{

@@ -122,9 +122,9 @@ func TestHandleEndpointsAdded(t *testing.T) {

 		"deleted":  {eventType: watch.Deleted, existing: true},

 	}

-	for name, c := range cases {

+	for name, tc := range cases {

 		existingFrontends := map[string]router.Frontend{}

-		if c.existing {

+		if tc.existing {

 			existingFrontends[testEndpointsName] = router.Frontend{}

 		}

@@ -132,7 +132,7 @@ func TestHandleEndpointsAdded(t *testing.T) {

 		controller := RouterController{

 			Router: testRouter,

 			NextEndpoints: func() (watch.EventType, *kapi.Endpoints) {

-				return c.eventType, &testEndpoints

+				return tc.eventType, &testEndpoints

 			},

 			NextRoute: func() (watch.EventType, *routeapi.Route) {

 				panic("Unreachable")

@@ -140,7 +140,7 @@ func TestHandleEndpointsAdded(t *testing.T) {

 		}

 		expectedFrontends := 0

-		if c.frontendCreated {

+		if tc.frontendCreated {

 			expectedFrontends = 1

 		}

@@ -155,7 +155,7 @@ func TestHandleEndpointsAdded(t *testing.T) {

 		}

 		addedRoutes, ok := testRouter.AddedRoutes[testEndpointsName]

-		if c.routesAdded {

+		if tc.routesAdded {

 			if !ok {

 				t.Errorf("Case %v: Two routes should have been added for %v", name, testEndpointsName)

 			}

@@ -105,25 +105,28 @@ func (routes *Routes) FindFrontend(name string) (v Frontend, ok bool) {

 }

 func (routes *Routes) DeleteBackends(name string) {

-	a, ok := routes.GlobalRoutes[name]

+	frontend, ok := routes.GlobalRoutes[name]

 	if !ok {

 		return

 	}

-	a.Backends = make(map[string]Backend)

-	a.EndpointTable = make(map[string]Endpoint)

-	routes.GlobalRoutes[name] = a

+	frontend.Backends = make(map[string]Backend)

+	frontend.EndpointTable = make(map[string]Endpoint)

+

+	routes.GlobalRoutes[name] = frontend

 }

 func (routes *Routes) CreateFrontend(name string, url string) {

-	a := Frontend{}

-	a.Backends = make(map[string]Backend)

-	a.EndpointTable = make(map[string]Endpoint)

-	a.Name = name

-	a.HostAliases = make([]string, 0)

+	frontend := Frontend{

+		Name:          name,

+		Backends:      make(map[string]Backend),

+		EndpointTable: make(map[string]Endpoint),

+		HostAliases:   make([]string, 0),

+	}

+

 	if url != "" {

-		a.HostAliases = append(a.HostAliases, url)

+		frontend.HostAliases = append(frontend.HostAliases, url)

 	}

-	routes.GlobalRoutes[a.Name] = a

+	routes.GlobalRoutes[frontend.Name] = frontend

 	routes.WriteRoutes()

 }

@@ -133,35 +136,35 @@ func (routes *Routes) DeleteFrontend(name string) {

 }

 func (routes *Routes) AddAlias(alias, frontendName string) {

-	a := routes.GlobalRoutes[frontendName]

-	for _, v := range a.HostAliases {

+	frontend := routes.GlobalRoutes[frontendName]

+	for _, v := range frontend.HostAliases {

 		if v == alias {

 			return

 		}

 	}

-	a.HostAliases = append(a.HostAliases, alias)

-	routes.GlobalRoutes[frontendName] = a

+	frontend.HostAliases = append(frontend.HostAliases, alias)

+	routes.GlobalRoutes[frontendName] = frontend

 	routes.WriteRoutes()

 }

 func (routes *Routes) RemoveAlias(alias, frontendName string) {

-	a := routes.GlobalRoutes[frontendName]

+	frontend := routes.GlobalRoutes[frontendName]

 	newAliases := make([]string, 0)

-	for _, v := range a.HostAliases {

+	for _, v := range frontend.HostAliases {

 		if v == alias || v == "" {

 			continue

 		}

 		newAliases = append(newAliases, v)

 	}

-	a.HostAliases = newAliases

-	routes.GlobalRoutes[frontendName] = a

+	frontend.HostAliases = newAliases

+	routes.GlobalRoutes[frontendName] = frontend

 	routes.WriteRoutes()

 }

 func (routes *Routes) AddRoute(frontendName, frontendPath, backendPath string, protocols []string, endpoints []Endpoint) {

 	var id string

-	a := routes.GlobalRoutes[frontendName]

+	frontend := routes.GlobalRoutes[frontendName]

 	epIDs := make([]string, 1)

 	for newEpId := range endpoints {

@@ -170,7 +173,7 @@ func (routes *Routes) AddRoute(frontendName, frontendPath, backendPath string, p

 			continue

 		}

 		found := false

-		for _, ep := range a.EndpointTable {

+		for _, ep := range frontend.EndpointTable {

 			if ep.IP == newEndpoint.IP && ep.Port == newEndpoint.Port {

 				epIDs = append(epIDs, ep.ID)

 				found = true

@@ -180,27 +183,27 @@ func (routes *Routes) AddRoute(frontendName, frontendPath, backendPath string, p

 		if !found {

 			id = makeID()

 			ep := Endpoint{id, newEndpoint.IP, newEndpoint.Port}

-			a.EndpointTable[id] = ep

+			frontend.EndpointTable[id] = ep

 			epIDs = append(epIDs, ep.ID)

 		}

 	}

 	// locate a backend that may already exist with this protocol and fe/be path

 	found := false

-	for _, be := range a.Backends {

+	for _, be := range frontend.Backends {

 		if be.FePath == frontendPath && be.BePath == backendPath && cmpStrSlices(protocols, be.Protocols) {

 			for _, epId := range epIDs {

 				be.EndpointIDs = append(be.EndpointIDs, epId)

 			}

-			a.Backends[be.ID] = be

+			frontend.Backends[be.ID] = be

 			found = true

 			break

 		}

 	}

 	if !found {

 		id = makeID()

-		a.Backends[id] = Backend{id, frontendPath, backendPath, protocols, epIDs, TERM_EDGE, nil}

+		frontend.Backends[id] = Backend{id, frontendPath, backendPath, protocols, epIDs, TERM_EDGE, nil}

 	}

-	routes.GlobalRoutes[a.Name] = a

+	routes.GlobalRoutes[frontend.Name] = frontend

 	routes.WriteRoutes()

 }

@@ -20,6 +20,7 @@ type Router struct {

 	RouterReloaded   bool

 }

+// NewRouter creates a new Router.

 func NewRouter(registeredFrontends map[string]router.Frontend) *Router {

 	return &Router{

 		FrontendsToFind:  registeredFrontends,