return name;
    }

    /**
     * Exhausts {@code toSign}, and writes the signature to {@code signatureDestination}.
     *
     * The caller is responsible for closing the streams, though the output WILL be flushed.
     */
    @Override
    public void sign(InputStream toSign, OutputStream signatureDestination) {
        PGPSignatureGenerator generator = createSignatureGenerator();
        try {

			clear(bitmap.b[:])
		}
	}
	// Enable checkmarking.
	useCheckmark = true
}

// endCheckmarks ends the checkmarks phase.
func endCheckmarks() {
	if gcMarkWorkAvailable(nil) {
		throw("GC work not flushed")
	}
	useCheckmark = false
}

// setCheckmark throws if marking object is a checkmarks violation,
// and otherwise sets obj's checkmark. It returns true if obj was
// already checkmarked.

	w.line[w.i] = '='
	w.i++

	return w.insertCRLF()
}

func (w *Writer) insertCRLF() error {
	w.line[w.i] = '\r'
	w.line[w.i+1] = '\n'
	w.i += 2

	return w.flush()
}

func (w *Writer) flush() error {
	if _, err := w.w.Write(w.line[:w.i]); err != nil {
		return err
	}

	w.i = 0
	return nil
}

func isWhitespace(b byte) bool {
	return b == ' ' || b == '\t'

		"legacy_path_translation_total",
		"Number of times a legacy API path is translated",
	)

	// CacheFlushTotal counts number of cache flushes.
	CacheFlushTotal = monitoring.NewSum(
		"cache_flush_total",
		"number of times operator cache was flushed",
	)
)

func init() {
	initOperatorCrdResourceMetrics()
}

func IncrementReconcileRequest(reason string) {

    }

    void doDaemonContext(gradleHandle, Closure assertions) {
        // poll here since even though the daemon has been marked as busy in the registry, the context may not have been
        // flushed to the log yet.
        DaemonContext context
        poll(5) {
            context = DaemonContextParser.parseFromString(gradleHandle.standardOutput, GradleVersion.current())
        }
        context.with(assertions)

	if _, err = tmpfile2.WriteString("just for testing"); err != nil {
		t.Fatalf("TestDiskUsage failed: %s", err.Error())
	}

	// File creation is not atomic. If we're calculating the DiskUsage before the data is flushed,
	// we'd get zeroes for sizes, and fail with this error:
	// TestDiskUsage failed: expected 0, got -1
	tmpfile1.Sync()
	tmpfile2.Sync()

	dirInfo1, err := os.Lstat(dir1)
	if err != nil {

        result.groupedOutput.task(':b:log').output == 'Interrupting output'
        result.groupedOutput.task(':b:log').outcome == null
    }

    def "long running task output are flushed after delay"() {
        server.start()

        given:
        buildFile << """
            task log {
                doLast {
                    logger.quiet 'Before'

// Write is blocking otherwise.
func (w *Writer) Write(p []byte) (n int, err error) {
	return w.pw.Write(p)
}

// Close closes the writer.
// Any accepted writes will be flushed. Any new writes will be rejected.
// Once Close() exits, files are synchronized to disk.
func (w *Writer) Close() error {
	w.pw.CloseWithError(nil)

	if w.f != nil {
		if err := w.closeCurrentFile(); err != nil {

//
// Returns whether the buffer was flushed.
func (w traceWriter) ensure(maxSize int) (traceWriter, bool) {
	refill := w.traceBuf == nil || !w.available(maxSize)
	if refill {
		w = w.refill(traceNoExperiment)
	}
	return w, refill
}

// flush puts w.traceBuf on the queue of full buffers.
func (w traceWriter) flush() traceWriter {
	systemstack(func() {
		lock(&trace.lock)

	// un-shaded stacks and flush after each stack scan.
	gcw := &pp.gcw
	pos := 0
	for _, ptr := range ptrs {
		if ptr < minLegalPointer {
			// nil pointers are very common, especially
			// for the "old" values. Filter out these and
			// other "obvious" non-heap pointers ASAP.
			//
			// TODO: Should we filter out nils in the fast
			// path to reduce the rate of flushes?
			continue
		}