github.com/go-stack/stack v1.8.0: Call.Frame

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/github.com/go-stack/stack@v1.8.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-stack/stack@v1.8.0
Demonstrate these symbols/APIs:
  - stack.Call.Frame

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

package sample

import (
	"strings"
	"testing"

	"github.com/go-stack/stack"
)

func levelA() stack.Call {
	return stack.Caller(0)
}

func levelB() (stack.Call, []stack.Call) {
	c := stack.Caller(0)
	cs := stack.Trace()
	return c, cs
}

func TestCallerFrame(t *testing.T) {
	call := levelA()
	frame := call.Frame()

	// 1. Verify Function name contains levelA
	if !strings.HasSuffix(frame.Function, "levelA") {
		t.Fatalf("expected function name ending with 'levelA', got %q", frame.Function)
	}

	// 2. Verify File contains contract_test.go
	if !strings.HasSuffix(frame.File, "contract_test.go") {
		t.Fatalf("expected file ending with 'contract_test.go', got %q", frame.File)
	}

	// 3. Verify Line is positive
	if frame.Line <= 0 {
		t.Fatalf("expected positive line number, got %d", frame.Line)
	}

	// 4. Verify PC is non-zero and Entry is non-zero
	if frame.PC == 0 {
		t.Fatalf("expected non-zero PC")
	}
	if frame.Entry == 0 {
		t.Fatalf("expected non-zero Entry")
	}
	if frame.PC < frame.Entry {
		t.Fatalf("expected PC (%x) >= Entry (%x)", frame.PC, frame.Entry)
	}
}

func TestCallerAndTraceConsistency(t *testing.T) {
	callerCall, traceCalls := levelB()

	if len(traceCalls) < 2 {
		t.Fatalf("expected at least 2 frames in trace, got %d", len(traceCalls))
	}

	callerFrame := callerCall.Frame()
	traceFrame := traceCalls[0].Frame()

	// Top frame in trace should be levelB
	if !strings.HasSuffix(traceFrame.Function, "levelB") {
		t.Fatalf("expected top trace frame to end with 'levelB', got %q", traceFrame.Function)
	}

	// Caller frame and top trace frame should refer to the same function and file
	if callerFrame.Function != traceFrame.Function {
		t.Fatalf("caller function %q != trace function %q", callerFrame.Function, traceFrame.Function)
	}
	if callerFrame.File != traceFrame.File {
		t.Fatalf("caller file %q != trace file %q", callerFrame.File, traceFrame.File)
	}

	fn, file, line, pc := InspectCallFrame(callerCall)
	if fn != callerFrame.Function || file != callerFrame.File || line != callerFrame.Line || pc != callerFrame.PC {
		t.Fatalf("InspectCallFrame mismatch")
	}
}

{"case":{"caseId":"case:sha256:9ad7366eb6502839af9f010fa2d8dcdb3f7829ab4aea3ab1473b1c67572baf2b","contract":["stack.Call.Frame returns runtime.Frame with valid Function, File, Line, and PC for a captured caller","stack.Call.Frame provides non-zero Entry point and PC address matching or exceeding Entry","stack.Call.Frame extracts consistent frame information across stack.Caller and stack.Trace frames"],"goal":"verify pkg:golang/github.com/go-stack/stack@v1.8.0","kind":"HOW","packages":["pkg:golang/github.com/go-stack/stack@v1.8.0"],"schemaVersion":1,"symbols":["stack.Call.Frame"]},"contractCommand":["go","test","./..."],"environment":{"arch":"amd64","compiler":"go","compilerVersion":"1.26.6","distro":"ubuntu","ecosystem":"golang","language":"go","languageVersion":"1.26.6","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/go-stack/stack@v1.8.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/go-stack/stack@v1.8.0","symbols":["stack.Call.Frame"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/go-stack/stack v1.8.0

github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=

package sample

import (
	"runtime"

	"github.com/go-stack/stack"
)

// GetCallerFrame returns the runtime.Frame for the function at skip levels above GetCallerFrame.
// skip=0 returns the immediate caller of GetCallerFrame.
func GetCallerFrame(skip int) runtime.Frame {
	call := stack.Caller(skip + 1)
	return call.Frame()
}

// GetTraceFrames returns runtime.Frame for each call in the current call stack.
func GetTraceFrames() []runtime.Frame {
	cs := stack.Trace()
	frames := make([]runtime.Frame, len(cs))
	for i, call := range cs {
		frames[i] = call.Frame()
	}
	return frames
}

// InspectCallFrame extracts key metadata from a stack.Call via its runtime.Frame.
func InspectCallFrame(c stack.Call) (function, file string, line int, pc uintptr) {
	frame := c.Frame()
	return frame.Function, frame.File, frame.Line, frame.PC
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/go-stack/stack@v1.8.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/go-stack/stack@v1.8.0"
  ],
  "symbols": [
    "stack.Call.Frame"
  ]
}