// is set by t*PIn being representable as a float64 without error
	// where t is given by t = floor(x * (1 / Pi)) and PIn are the leading partial
	// terms of Pi. Since the leading terms, PI1 and PI2 below, have 30 and 32
	// trailing zero bits respectively, t should have less than 30 significant bits.
	//	t < 1<<30  -> floor(x*(1/Pi)+0.5) < 1<<30 -> x < (1<<30-1) * Pi - 0.5
	// So, conservatively we can take x < 1<<30.
	const reduceThreshold float64 = 1 << 30

            /*
             * Samba has a tendency to return pathConsumed values so that they consume a trailing slash of the
             * requested path. Normalize this here.
             */
            if ( reqPath.charAt(consumed - 1) == '\\' ) {
                if ( log.isDebugEnabled() ) {
                    log.debug("Server consumed trailing slash of request path, adjusting");
                }
                dr.pathConsumed--;

__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.")