prevStack := "x"
	for pc := pc1; pc < pc1+1024 && findfunc(pc) == f; pc += sys.PCQuantum {
		stack := ""
		u, uf := newInlineUnwinder(f, pc)
		if file, _ := u.fileLine(uf); file == "?" {
			// We're probably in the trailing function padding, where findfunc
			// still returns f but there's no symbolic information. Just keep
			// going until we definitely hit the end. If we see a "?" in the
			// middle of unwinding, that's a real problem.
			//

}

var etagRegex = regexp.MustCompile("\"*?([^\"]*?)\"*?$")

// canonicalizeETag returns ETag with leading and trailing double-quotes removed,
// if any present
func canonicalizeETag(etag string) string {
	return etagRegex.ReplaceAllString(etag, "$1")
}

// Init - populates the input values, initializes CondCheck

__kubeadm_type() {
	# -t is not supported by zsh
	if [ "$1" == "-t" ]; then
		shift

		# fake Bash 4 to disable "complete -o nospace". Instead
		# "compopt +-o nospace" is used in the code to toggle trailing
		# spaces. We don't support that, but leave trailing spaces on
		# all the time
		if [ "$1" = "__kubeadm_compopt" ]; then
			echo builtin
			return 0
		fi
	fi
	type "$@"
}

__kubeadm_compgen() {

// - include <filename>: returns the content of that file as string
// - indent <number of spaces> <string>: replace each newline with "newline + spaces", indent the newline at the end
// - trim <string>: strip leading and trailing whitespace

func main() {
	kvs := make(map[string]string)

	for _, keyValue := range os.Args[1:] {
		index := strings.Index(keyValue, "=")
		if index <= 0 {

std::optional<CalibrationStatistics>
CalibrationStatisticsCollectorHistogram::GetStatistics() const {
  if (hist_freq_.empty()) return std::nullopt;

  CalibrationStatistics::HistogramStatistics hist_stats;

  // Skip trailing zeros in the histogram.
  int32_t real_size = hist_freq_.size();
  for (; real_size > 0; --real_size) {
    if (hist_freq_[real_size - 1] != 0) break;
  }

  hist_stats.set_lower_bound(lower_bound_);

    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);
    if (!lines.isEmpty()) {
      // if we wrote any lines in writeLines(), there will be a trailing newline
      expected += separator;
    }
    assertEquals(expected, factory.getSinkContents());
  }

	for {
		pos, tok, lit := s.Scan()
		switch tok {
		case token.EOF:
			return
		case token.COMMENT:
			if lit[1] == '*' {
				lit = lit[:len(lit)-2] // strip trailing */
			}
			lit = lit[2:] // strip leading // or /*
			if rx.MatchString(lit) {
				p := fset.Position(prev)
				err := comment{p.Line, p.Column, lit}
				if res == nil {
					res = make(map[int][]comment)
				}

			return nil
		}
		bytes, err := os.ReadFile(path)
		if err != nil {
			return err
		}
		matched := pattern.FindAllString(string(bytes), -1)
		for _, m := range matched {
			// Add the match, with trailing ( and previous `func ` stripped
			matches = append(matches, m[5:len(m)-1])
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return matches, nil
}

-----END CERTIFICATE-----`
)

var (
	certChainValid             = loadPEMFile("../testdata/cert-chain.pem")
	certChainValidTrailingLine = loadPEMFile("../testdata/cert-chain-trailing-line.pem")
)

func TestParsePemEncodedCertificate(t *testing.T) {
	testCases := map[string]struct {
		errMsg        string
		pem           string
		publicKeyAlgo x509.PublicKeyAlgorithm
	}{

        formatter.endChildren()

        then:
        formatter.toString() == toPlatformLineSeparators("""${longText}:
  - ${longText}""")
    }

    def "formats node with trailing '.'"() {
        when:
        formatter.node("Some things.")
        formatter.startChildren()
        formatter.node("child 1.")
        formatter.endChildren()
        formatter.node("Some other things.")