@VisibleForTesting
  @CheckForNull
  synchronized File getFile() {
    return file;
  }

  /**
   * Creates a new instance that uses the given file threshold, and does not reset the data when the
   * {@link ByteSource} returned by {@link #asByteSource} is finalized.
   *
   * @param fileThreshold the number of bytes before the stream should switch to buffering to a file

  @VisibleForTesting
  @CheckForNull
  synchronized File getFile() {
    return file;
  }

  /**
   * Creates a new instance that uses the given file threshold, and does not reset the data when the
   * {@link ByteSource} returned by {@link #asByteSource} is finalized.
   *
   * @param fileThreshold the number of bytes before the stream should switch to buffering to a file

namespace mlir {
namespace TF {

// Implements a TF specific policy on when constant folding is allowed.
// Policy:
//
// Disable constant folding if operands size is greater than a certain
// threshold (`kOperandsSizeThreshold`).
//
// Otherwise, allow folding if we do not know the shape of an operand or
// result i.e., one of these values has non-static shape. If we know all the

package cmd

import (
	"math"
	"sync"
	"sync/atomic"
	"time"
)

const (
	dynamicTimeoutIncreaseThresholdPct = 0.33 // Upper threshold for failures in order to increase timeout
	dynamicTimeoutDecreaseThresholdPct = 0.10 // Lower threshold for failures in order to decrease timeout
	dynamicTimeoutLogSize              = 16
	maxDuration                        = math.MaxInt64

 * under the License.
 */
package org.apache.maven.logwrapper;

import java.util.Optional;

import org.slf4j.ILoggerFactory;

/**
 * Wrapper for creating loggers which can have a log level threshold.
 */
public interface MavenSlf4jWrapperFactory extends ILoggerFactory {
    void setLogLevelRecorder(LogLevelRecorder logLevelRecorder);

    Optional<LogLevelRecorder> getLogLevelRecorder();

	}

	err := errorIfMessagesExceedThreshold(msgs)

	g.Expect(err).To(BeNil())
}

func TestSkipPodsInFiles(t *testing.T) {
	c := testutil.TestCase{
		Args: strings.Split(
			"-A --use-kube=false --failure-threshold ERROR testdata/analyze-file/public-gateway.yaml",
			" "),
		WantException: false,
	}
	analyze := Analyze(cli.NewFakeContext(nil))
	testutil.VerifyOutput(t, analyze, c)

package pgo

// Profile contains the processed data from the PGO profile.
type Profile struct {
	// TotalWeight is the aggregated edge weights across the profile. This
	// helps us determine the percentage threshold for hot/cold
	// partitioning.
	TotalWeight int64

	// NamedEdgeMap contains all unique call edges in the profile and their
	// edge weight.
	NamedEdgeMap NamedEdgeMap
}

                              n->name());
    }
    total_elements *= dim.size();
  }

  // TODO(sanjoy): It may make sense to combine this threshold with XLA's "large
  // constant" threshold, if there is one.
  const int kSmallTensorThreshold = 16;
  return total_elements < kSmallTensorThreshold;
}

// We only clone small constants since we want to avoid increasing memory

        Throwable thrown = assertThrows(IllegalArgumentException.class, () -> new LogLevelRecorder("SEVERE"));
        String message = thrown.getMessage();
        assertThat(message, containsString("SEVERE is not a valid log severity threshold"));
        assertThat(message, containsString("WARN"));
        assertThat(message, containsString("WARNING"));
        assertThat(message, containsString("ERROR"));
    }

import org.slf4j.Logger;
import org.slf4j.simple.SimpleLoggerFactory;

/**
 * LogFactory for Maven which can create a simple logger or one which, if set, fails the build on a severity threshold.
 */
public class MavenLoggerFactory extends SimpleLoggerFactory implements MavenSlf4jWrapperFactory {
    private LogLevelRecorder logLevelRecorder = null;

    public MavenLoggerFactory() {}

    @Override