stack: make tests more resilient

Use the occasion to rename function arguments to make it easier to
understand.

Test only change.

Author: maruel

stack/context_test.go

@@ -2017,9 +2017,9 @@ func testPanicUTF8(t *testing.T, s *Snapshot, b *bytes.Buffer, ppDir string) {
 							// not.
 							"github.com/maruel/panicparse"+ver+"/cmd/panic/internal/utf8.(*Strùct).Pànic",
 							ifCombinedAggregateArgs(
-								Args{Values: []Arg{{Value: 1}}},
+								Args{Values: []Arg{{Value: 1, IsInaccurate: true}}},
 								// else
-								Args{Values: []Arg{{Value: 0xc0000b2e48, IsPtr: true}}},
+								Args{Values: []Arg{{Value: 0xc0000b2e48, IsPtr: true, IsInaccurate: true}}},
 							),
 							// See TestCallUTF8 in stack_test.go for exercising the methods on
 							// Call in this situation.
@@ -2286,15 +2286,15 @@ func identifyPanicwebSignature(t *testing.T, b *Bucket, pwebDir string) panicweb
 			t.Fatal("first bucket is not correct")
 			return pstUnknown
 		}
-		crash := Signature{
+		want := Signature{
 			State: "running",
 			Stack: Stack{
 				Calls: []Call{
 					newCallLocal("main.main", Args{}, pathJoin(pwebDir, "main.go"), 80),
 				},
 			},
 		}
-		similarSignatures(t, &crash, &b.Signature)
+		similarSignatures(t, &want, &b.Signature)
 		return pstMain
 	}
 
@@ -2360,13 +2360,15 @@ func identifyPanicwebSignature(t *testing.T, b *Bucket, pwebDir string) panicweb
 		}
 		// That's the unix.Nanosleep() or windows.SleepEx() call.
 		if b.State == "syscall" {
-			created := Stack{
-				Calls: []Call{
-					newCallLocal("main.main", Args{}, pathJoin(pwebDir, "main.go"), 63),
-				},
+			{
+				want := Stack{
+					Calls: []Call{
+						newCallLocal("main.main", Args{}, pathJoin(pwebDir, "main.go"), 63),
+					},
+				}
+				zapStacks(t, &want, &b.CreatedBy)
+				compareStacks(t, &want, &b.CreatedBy)
 			}
-			zapStacks(t, &created, &b.CreatedBy)
-			compareStacks(t, &created, &b.CreatedBy)
 			if l := len(b.IDs); l != 1 {
 				t.Fatalf("expected 1 goroutine for the signature, got %d", l)
 			}
@@ -2412,24 +2414,26 @@ func identifyPanicwebSignature(t *testing.T, b *Bucket, pwebDir string) panicweb
 					t.Fatalf("unexpected version string %q", ver)
 				}
 			}
-			rest := []Call{
-				newCallLocal("main.sysHang", Args{}, pathJoin(pwebDir, mainOS), 12),
-				newCallLocal(
-					"main.main.func3",
-					ifCombinedAggregateArgs(
-						Args{},
-						// else
-						Args{Values: []Arg{{Value: 0xc000140720, Name: "#135", IsPtr: true}}},
-					),
-					pathJoin(pwebDir, "main.go"),
-					65),
-			}
-			got := b.Stack.Calls[2:]
-			for i := range rest {
-				zapCalls(t, &got[i], &rest[i])
-			}
-			if diff := cmp.Diff(rest, got); diff != "" {
-				t.Fatalf("rest of stack mismatch (-want +got):\n%s", diff)
+			{
+				want := []Call{
+					newCallLocal("main.sysHang", Args{}, pathJoin(pwebDir, mainOS), 12),
+					newCallLocal(
+						"main.main.func3",
+						ifCombinedAggregateArgs(
+							Args{},
+							// else
+							Args{Values: []Arg{{Value: 0xc000140720, Name: "#135", IsPtr: true}}},
+						),
+						pathJoin(pwebDir, "main.go"),
+						65),
+				}
+				got := b.Stack.Calls[2:]
+				for i := range want {
+					zapCalls(t, &want[i], &got[i])
+				}
+				if diff := cmp.Diff(want, got); diff != "" {
+					t.Fatalf("rest of stack mismatch (-want +got):\n%s", diff)
+				}
 			}
 			return pstStdlib
 		}

stack/stack_test.go

@@ -426,14 +426,14 @@ func similarGoroutines(t *testing.T, want, got []*Goroutine) {
 	}
 }
 
-func zapGoroutines(t *testing.T, a, b []*Goroutine) {
-	if len(a) != len(b) {
+func zapGoroutines(t *testing.T, want, got []*Goroutine) {
+	if len(want) != len(got) {
 		t.Error("different []*Goroutine length")
 		return
 	}
-	for i := range a {
+	for i := range want {
 		// &(*Goroutine).Signature
-		zapSignatures(t, &a[i].Signature, &b[i].Signature)
+		zapSignatures(t, &want[i].Signature, &got[i].Signature)
 	}
 }
 
@@ -448,55 +448,58 @@ func similarSignatures(t *testing.T, want, got *Signature) {
 	}
 }
 
-func zapSignatures(t *testing.T, a, b *Signature) {
+func zapSignatures(t *testing.T, want, got *Signature) {
 	// Signature.Stack.([]Call)
-	if len(a.Stack.Calls) != len(b.Stack.Calls) {
+	if len(want.Stack.Calls) != len(got.Stack.Calls) {
 		t.Error("different call length")
 		return
 	}
-	if len(a.CreatedBy.Calls) != 0 && len(b.CreatedBy.Calls) != 0 {
-		if a.CreatedBy.Calls[0].Line != 0 && b.CreatedBy.Calls[0].Line != 0 {
-			a.CreatedBy.Calls[0].Line = 42
-			b.CreatedBy.Calls[0].Line = 42
+	if len(want.CreatedBy.Calls) != 0 && len(got.CreatedBy.Calls) != 0 {
+		if want.CreatedBy.Calls[0].Line != 0 && got.CreatedBy.Calls[0].Line != 0 {
+			want.CreatedBy.Calls[0].Line = 42
+			got.CreatedBy.Calls[0].Line = 42
 		}
 	}
-	zapStacks(t, &a.Stack, &b.Stack)
+	zapStacks(t, &want.Stack, &got.Stack)
 }
 
-func zapStacks(t *testing.T, a, b *Stack) {
-	if len(a.Calls) != len(b.Calls) {
+func zapStacks(t *testing.T, want, got *Stack) {
+	if len(want.Calls) != len(got.Calls) {
 		t.Error("different Stack.[]Call length")
 		return
 	}
-	for i := range a.Calls {
-		zapCalls(t, &a.Calls[i], &b.Calls[i])
+	for i := range want.Calls {
+		zapCalls(t, &want.Calls[i], &got.Calls[i])
 	}
 }
 
-func zapCalls(t *testing.T, a, b *Call) {
-	if a.Line != 0 && b.Line != 0 {
-		a.Line = 42
-		b.Line = 42
+func zapCalls(t *testing.T, want, got *Call) {
+	if want.Line != 0 && got.Line != 0 {
+		want.Line = 42
+		got.Line = 42
 	}
-	zapArgs(t, &a.Args, &b.Args)
+	zapArgs(t, &want.Args, &got.Args)
 }
 
-func zapArgs(t *testing.T, a, b *Args) {
-	if len(a.Values) != len(b.Values) {
+func zapArgs(t *testing.T, want, got *Args) {
+	if len(want.Values) != len(got.Values) {
 		t.Error("different Args.Values length")
 		return
 	}
-	for i := range a.Values {
-		if a.Values[i].Value != 0 && b.Values[i].Value != 0 {
-			a.Values[i].Value = 42
-			b.Values[i].Value = 42
+	for i := range want.Values {
+		if want.Values[i].Value != 0 && got.Values[i].Value != 0 {
+			want.Values[i].Value = 42
+			got.Values[i].Value = 42
 		}
-		if a.Values[i].IsAggregate && b.Values[i].IsAggregate {
-			zapArgs(t, &a.Values[i].Fields, &b.Values[i].Fields)
+		if want.Values[i].IsAggregate && got.Values[i].IsAggregate {
+			zapArgs(t, &want.Values[i].Fields, &got.Values[i].Fields)
 		}
-		if a.Values[i].Name != "" && b.Values[i].Name != "" {
-			a.Values[i].Name = "foo"
-			b.Values[i].Name = "foo"
+		if want.Values[i].Name != "" && got.Values[i].Name != "" {
+			want.Values[i].Name = "foo"
+			got.Values[i].Name = "foo"
+		}
+		if want.Values[i].IsInaccurate && !got.Values[i].IsInaccurate {
+			want.Values[i].IsInaccurate = false
 		}
 	}
 }