//
// If two Stacks are equal then their Frames are guaranteed to be identical. If they are not
// equal, however, their Frames may still be equal.
type Stack struct {
	table *evTable
	id    stackID
}

// Frames is an iterator over the frames in a Stack.
func (s Stack) Frames(yield func(f StackFrame) bool) bool {
	if s.id == 0 {
		return true
	}

travis-enable-project.png...

						break
					}
					i++
				}
				tb.frames = tb.frames[1:]
			}
			if !t.Failed() && len(tb.frames) > 0 {
				t.Errorf("got %d more frames than expected", len(tb.frames))
			}
			if t.Failed() {
				t.Logf("traceback diverged at frame %d", i)
				off := len(stack)
				if len(tb.frames) > 0 {
					off = tb.frames[0].off
				}
				t.Logf("traceback before error:\n%s", stack[:off])

The failure prints stack traces for all goroutines if there is no current goroutine
or the failure is internal to the run-time.
GOTRACEBACK=none omits the goroutine stack traces entirely.
GOTRACEBACK=single (the default) behaves as described above.
GOTRACEBACK=all adds stack traces for all user-created goroutines.
GOTRACEBACK=system is like “all” but adds stack frames for run-time functions

		"Drops functions above the highest matched frame.",
		"If set, all frames above the highest match are dropped from every sample.",
		"Matching includes the function name, filename or object name."),
	"tagroot": helpText(
		"Adds pseudo stack frames for labels key/value pairs at the callstack root.",
		"A comma-separated list of label keys.",
		"The first key creates frames at the new root."),
	"tagleaf": helpText(

}

func main() {
	for i := 0; i <= 5; i++ {
		frames := testCallers(i)
		expected := expectedFrames[i]
		if !same(frames, expected) {
			fmt.Printf("testCallers(%d):\n got %v\n want %v\n", i, frames, expected)
		}

		frames = testCallersFrames(i)
		expected = allFrames[i:]
		if !same(frames, expected) {
			fmt.Printf("testCallersFrames(%d):\n got %v\n want %v\n", i, frames, expected)
		}
	}

	if err != io.EOF {
		t.Fatal(err)
	}
}

func TestDecoder(t *testing.T) {
	frames := [][]byte{
		make([]byte, 1025),
		make([]byte, 1024*5),
		make([]byte, 1024*1024*17),
		make([]byte, 1025),
	}
	pr, pw := io.Pipe()
	fw := framer.NewLengthDelimitedFrameWriter(pw)
	go func() {
		for i := range frames {
			fw.Write(frames[i])
		}
		pw.Close()
	}()

	r := framer.NewLengthDelimitedFrameReader(pr)

files: "fake/user/code/file_y.py"
files: "fake/user/code/file_z.py"
traces {
  key: "MobilenetV1/Conv2d_0/BatchNorm/beta@"
  value {
    file_line_cols {
      file_index: 33
      line: 383
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/BatchNorm/beta/read@"
  value {
    file_line_cols {
      file_index: 49
      line: 886
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/BatchNorm/gamma@"
  value {

	return x + 1
}

func test() {
	defer func() {
		if r := recover(); r != nil {
			pcs := make([]uintptr, 10)
			n := runtime.Callers(0, pcs)
			pcs = pcs[:n]
			frames := runtime.CallersFrames(pcs)
			for {
				f, more := frames.Next()
				if f.Function == "main.foo" {
					println("did not expect to see call to foo in stack trace")
					os.Exit(1)
				}
				if !more {
					break
				}
			}
		}

		{"main.TracebackContext", 0},
	}

	ok := true
	i := 0
wantLoop:
	for _, w := range want {
		for ; i < len(frames); i++ {
			if w.function == frames[i].Function {
				if w.line != 0 && w.line != frames[i].Line {
					fmt.Printf("found function %s at wrong line %#x (expected %#x)\n", w.function, frames[i].Line, w.line)
					ok = false
				}
				i++
				continue wantLoop
			}
		}