}
			return nil
		}
	}
	hasFlush := func(want bool) checkFunc {
		return func(rec *ResponseRecorder) error {
			if rec.Flushed != want {
				return fmt.Errorf("Flushed = %v; want %v", rec.Flushed, want)
			}
			return nil
		}
	}
	hasOldHeader := func(key, want string) checkFunc {
		return func(rec *ResponseRecorder) error {
			if got := rec.HeaderMap.Get(key); got != want {

		}

		// Write out a trace event.
		w := unsafeTraceWriter(gen, trace.cpuBuf[gen%2])

		// Ensure we have a place to write to.
		var flushed bool
		w, flushed = w.ensure(2 + 5*traceBytesPerNumber /* traceEvCPUSamples + traceEvCPUSample + timestamp + g + m + p + stack ID */)
		if flushed {
			// Annotate the batch as containing strings.
			w.byte(byte(traceEvCPUSamples))
		}

		// Add the stack to the table.

    /**
     * Writes the given value and returns an address for the written block.
     * The current thread performs the encoding. The implementation may perform some buffering and this may not necessarily be
     * flushed to the filesystem on completion of this method.
     */
    BlockAddress write(T value);

    /**
     * Reads the contents of the given block.
     * The current thread performs the decoding.
     */

     */
    @Internal
    String getName();

    /**
     * Exhausts {@code toSign}, and writes the signature to {@code signatureDestination}. The caller is responsible for closing the streams, though the output WILL be flushed.
     *
     * @param toSign The source of the data to be signed
     * @param destination Where the signature will be written to
     */
    void sign(InputStream toSign, OutputStream destination);

    /**

	err := ct.exec(parameters...)
	if err != nil && !strings.Contains(err.Error(), noConnectionToDelete) {
		// TODO: Better handling for deletion failure. When failure occur, stale udp connection may not get flushed.
		// These stale udp connection will keep black hole traffic. Making this a best effort operation for now, since it
		// is expensive to baby-sit all udp connections to kubernetes services.

// limitations under the License.

package ledger

import (
	"sync"
	"time"

	"istio.io/istio/pkg/cache"
)

type cacheDB struct {
	// updatedNodes that have will be flushed to disk
	updatedNodes byteCache
	// updatedMux is a lock for updatedNodes
	updatedMux sync.RWMutex
}

// byteCache implements a modified ExpiringCache interface, returning byte arrays

 * <p>
 * ModelSource2 instances are cached in {@link ModelBuildingRequest#getModelCache()}. Implementations must guarantee
 * that the connection to the backing store remains active until request's {@link ModelCache} is discarded or flushed.
 */
public interface ModelSource2 extends ModelSource {
    /**
     * Returns model source identified by a path relative to this model source POM. Implementation <strong>MUST</strong>

        10_000 * listener.onOutput(_)
    }

    def "background flush does nothing when events already flushed"() {
        def event1 = event('1')
        def event2 = event('2')
        def flush = new FlushOutputEvent()

        given:
        renderer.onOutput(event1)
        renderer.onOutput(event2)
        renderer.onOutput(flush)

        when:
        executor.runFixedScheduledActionsNow()

	bufferCh chan *metric
	// if bufferSize is reached, incoming metrics will be discarded.
	bufferSize int
	// how often the recorder runs to flush the metrics.
	interval time.Duration

	// stopCh is used to stop the goroutine which periodically flushes metrics.
	stopCh <-chan struct{}
	// IsStoppedCh indicates whether the goroutine is stopped. It's used in tests only to make sure

	return traceExpWriter{traceWriter{traceLocker: traceLocker{gen: gen}, traceBuf: buf}, exp}
}

// ensure makes sure that at least maxSize bytes are available to write.
//
// Returns whether the buffer was flushed.
func (w traceExpWriter) ensure(maxSize int) (traceExpWriter, bool) {
	refill := w.traceBuf == nil || !w.available(maxSize)
	if refill {
		w.traceWriter = w.traceWriter.refill(w.exp)
	}
	return w, refill
}