.

go/internal/xtracing/tracetest/example_test.go

@@ -140,6 +140,7 @@ func Test2ThreadsOK(t *testing.T) {
 }
 
 // TestDeadlock demonstrates deadlock detection.
+// XXX also test for wrong decomposition   XXX or is it also covered by this test as well?
 func TestDeadlock(t *testing.T) {
 	verify(t, func(t *tracetest.T) {
 		var wg sync.WaitGroup
@@ -296,8 +297,8 @@ var testExpectMap = map[string]testExpect{
 
 	"TestDeadlock":   {1,
 `--- FAIL: TestDeadlock (<TIME>)
-    example_test.go:156: t2: recv: deadlock waiting for *tracetest_test.eventHi
-    example_test.go:156: test shutdown: #streams: 2,  #(pending events): 1
+    example_test.go:157: t2: recv: deadlock waiting for *tracetest_test.eventHi
+    example_test.go:157: test shutdown: #streams: 2,  #(pending events): 1
         t1	<- tracetest_test.eventHi T1·A
         # t2
 
@@ -306,7 +307,7 @@ var testExpectMap = map[string]testExpect{
 
 	"TestRace":       {1,
 `    --- FAIL: TestRace/delay@0(=x:0) (<TIME>)
-        example_test.go:182: x: expect: tracetest_test.eventHi:
+        example_test.go:183: x: expect: tracetest_test.eventHi:
             want: x·A
             have: x·B
             diff:
@@ -316,8 +317,8 @@ var testExpectMap = map[string]testExpect{
 
 	"TestExpectType": {1,
 `--- FAIL: TestExpectType (<TIME>)
-    example_test.go:202: t1: expect: tracetest_test.eventHello:  got tracetest_test.eventHi T1·A
-    example_test.go:202: test shutdown: #streams: 1,  #(pending events): 0
+    example_test.go:203: t1: expect: tracetest_test.eventHello:  got tracetest_test.eventHi T1·A
+    example_test.go:203: test shutdown: #streams: 1,  #(pending events): 0
         # t1
 
     tracetest.go:<LINE>: t1: send: unexpected event type
@@ -325,14 +326,14 @@ var testExpectMap = map[string]testExpect{
 
 	"TestExpectValue": {1,
 `--- FAIL: TestExpectValue (<TIME>)
-    example_test.go:218: t1: expect: tracetest_test.eventHi:
+    example_test.go:219: t1: expect: tracetest_test.eventHi:
         want: T1·B
         have: T1·A
         diff:
         -"T1·B"
         +"T1·A"
 
-    example_test.go:218: test shutdown: #streams: 1,  #(pending events): 0
+    example_test.go:219: test shutdown: #streams: 1,  #(pending events): 0
         # t1
 
     tracetest.go:<LINE>: t1: send: unexpected event data

go/internal/xtracing/tracetest/tracetest.go

@@ -99,6 +99,8 @@ var (
 	deadTime = flag.Duration("tracetest.deadtime", 3*time.Second, "time after which no events activity is considered to be a deadlock")
 )
 
+// XXX hide Chan from public API
+
 // Chan provides synchronous channel with additional property that send
 // blocks until receiving side explicitly acknowledges message was received and
 // processed.
@@ -529,6 +531,7 @@ func (t *T) queuenak(msg *Msg, why string) {
 
 
 // XXX doc; naming
+// XXX document routeEvent requirements
 func (t *T) SetEventRouter(routeEvent func(event interface{}) (stream string)) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
@@ -544,11 +547,14 @@ func (t *T) SetEventRouter(routeEvent func(event interface{}) (stream string)) {
 // XXX pass events in not via t (via something dedicated)?
 func (t *T) RxEvent(event interface{}) {
 	t0 := time.Now()
-	stream := "default"
+	stream := ""
 	t.mu.Lock()
 	if t.routeEvent != nil {
 		stream = t.routeEvent(event)
 	}
+	if stream == "" {
+		stream = "default"
+	}
 	t.tracev = append(t.tracev, eventTrace{t0, stream, event})
 	ch := t.chanForStream(stream)
 
@@ -885,8 +891,6 @@ func Verify(t *testing.T, f func(t *T)) {
 				return
 			}
 			streams := streamsOfTrace(tT.tracev)
-			fmt.Printf("streams0: %v\n", streams0)
-			fmt.Printf("streams:  %v\n", streams)
 			if !reflect.DeepEqual(streams, streams0) {
 				tT.Fatalf("streams are not the same as in the first run:\n"+
 					  "first: %s\nnow:   %s\ndiff:\n%s\n\n",