"istio.io/istio/pkg/slices"
	"istio.io/istio/pkg/test/util/assert"
)

func TestLazySerial(t *testing.T) {
	t.Run("retry", func(t *testing.T) {
		computations := atomic.NewInt32(0)
		l := NewWithRetry(func() (int32, error) {
			res := computations.Inc()
			if res > 2 {
				return res, nil
			}

			return res, fmt.Errorf("not yet")
		})
		res, err := l.Get()
		assert.Error(t, err)

    // a) argument and return value, for entry computations b) variables, for
    // all computations, should be represented in XLA. Parameters/return values
    // will be shaped according to the function pair, and reshaped back to/from
    // their declared shapes for computations. Must be non-empty.
    std::vector<XlaShapeLayoutHelpers::ShapeDeterminationFns>
        shape_determination_fns;

limitations under the License.
==============================================================================*/

// This file defines the tf_device dialect: it contains operations that model
// TensorFlow's actions to launch computations on accelerator devices.

#ifndef TENSORFLOW_COMPILER_MLIR_TENSORFLOW_IR_TF_DEVICE_H_
#define TENSORFLOW_COMPILER_MLIR_TENSORFLOW_IR_TF_DEVICE_H_

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project

// Rewrites computations generated by the xla.compile() Python code into
// XlaLaunch nodes.
//
// xla.compile() does two main things:
// a) marks operators that make up an XLA computation with the attribute
//    _xla_compile_id=XYZ, where XYZ is a unique key.
// b) adds XlaClusterOutput nodes to represent outputs of the computation.
//    These nodes are not marked with the _xla_compile_id attribute.

    // a) argument and return value, for entry computations b) variables, for
    // all computations, should be represented in XLA. Parameters/return values
    // will be shaped according to the function pair, and reshaped back to/from
    // their declared shapes for computations. Must be non-empty.
    std::vector<XlaShapeLayoutHelpers::ShapeDeterminationFns>

import java.util.function.Supplier

class ManualEvictionInMemoryCacheTest extends Specification {

    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    def "supports #concurrency concurrent computations"() {
        def latch = new CountDownLatch(concurrency)
        def executor = Executors.newFixedThreadPool(concurrency)
        def cache = new ManualEvictionInMemoryCache<String, String>()

        when:

namespace mlir {
namespace TF {

// Populates rewrite patterns that decompose composite resource operations into
// primitive ones like ReadVariableOp, AssignVariableOp and other computations
// to facilitate transformations like resource op lifting.
// NOTE: These patterns do not support `use_locking=true` for a lot of resource
// operations. So decomposition may not be correct outside of backends like XLA,

      return errors::InvalidArgument(
          "Undeclared output of XLA computation. Some common causes of this "
          "error are: 1) variable initializers that depend on the XLA "
          "computation; 2) gradient computations that depend on the XLA "
          "computation, which can be mitigated by moving gradient computations "
          "inside XLA computation. Offending edge: ",

#include "tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.pb.h"

namespace mlir {
namespace quant {

// Check if the op has data movement trait. Ops with this trait do not perform
// any computations but just move data and has one result operand.
bool IsOpWithDataMovementTrait(Operation* op);

// Check if the op is quantizable. Currently, the scope of quantizable op is

// a customizable variant of SHAKE128.
// N is used to define functions based on cSHAKE, it can be empty when plain cSHAKE is
// desired. S is a customization byte string used for domain separation - two cSHAKE
// computations on same input with different S yield unrelated outputs.
// When N and S are both empty, this is equivalent to NewShake128.
func NewCShake128(N, S []byte) ShakeHash {
	if len(N) == 0 && len(S) == 0 {
		return NewShake128()