return new EnvVariableInjection() {
            @Override
            String getDescription() {
                return "using environment variable"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.withEnvironmentVars(variables)
            }
        }
    }

        Variable match = null;
        for (Variable variable : variables) {
            if (file.getAbsolutePath().equals(variable.getDir().getAbsolutePath())) {
                match = variable;
                break;
            }
            if (file.getAbsolutePath().startsWith(variable.getPrefix())) {
                if (match == null || variable.getPrefix().startsWith(match.getPrefix())) {

		CompositionEnv: context,
	}
}

func (c *CompositedCompiler) CompileAndStoreVariables(variables []NamedExpressionAccessor, options OptionalVariableDeclarations, mode environment.Type) {
	for _, v := range variables {
		_ = c.CompileAndStoreVariable(v, options, mode)
	}
}

func (c *CompositedCompiler) CompileAndStoreVariable(variable NamedExpressionAccessor, options OptionalVariableDeclarations, mode environment.Type) CompilationResult {

  def __init__(self):
    self.arr1 = [1.]
    self.const_arr = [constant_op.constant(1.)]
    self.var_arr = [variables.Variable(1.), variables.Variable(2.)]
    self.dict1 = {"a": 1.}
    self.var_dict = {"a": variables.Variable(1.), "b": variables.Variable(2.)}


class SimpleModel(module.Module):
  """A simple model used for exercising the C++ API."""

  @def_function.function(input_signature=[

        for i, j, k, l = range s {} // ERROR "range clause permits at most two iteration variables"
}

func _(s chan int) {
        var i, j, k, l int
        _, _, _, _ = i, j, k, l

        for range s {}
        for i = range s {}
        for i, j = range s {} // ERROR "range over .* permits only one iteration variable"

}

// OptionalVariableDeclarations declares which optional CEL variables
// are declared for an expression.
type OptionalVariableDeclarations struct {
	// HasParams specifies if the "params" variable is declared.
	// The "params" variable may still be bound to "null" when declared.
	HasParams bool
	// HasAuthorizer specifies if the "authorizer" and "authorizer.requestResource"
	// variables are declared. When declared, the authorizer variables are

func _() {
	_ := /* ERROR "no new variables" */ 0
	_, a := 0, 1
	_, a := /* ERROR "no new variables" */ 0, 1
	_, a, b := 0, 1, 2
	_, _, _ := /* ERROR "no new variables" */ 0, 1, 2

	_ = a
	_ = b
}

// Test case for variables depending on function literals (see also #22992).
var A /* ERROR "initialization cycle" */ = func() int { return A }()

func _() {
	// The function literal below must not see a.

# variables in it, OR may be left empty if the user has already exported the
# relevant variables in their environment. Because of 'set -o allexport' above
# (which is equivalent to "set -a"), every variable in the file is exported
# for other files to use.
#
# Separately, if TFCI is set *and* there are also additional TFCI_ variables

// Populates the OpKernelContext outputs with the outputs of the
// PjRtLoadedExecutable. Requires the `compilation_result` used to build the
// PjRtLoadedExecutable.
// This function only looks at variables that were updated, so `variables` can
// either be all the variables or only the ones that were updated.
// Assumes that the first `num_missing_prefix_ctx_inputs` inputs to the
// compilation_result are missing in `inputs` and adjusts indexing into `inputs`

    std::string saved_model_dir = "");

// Creates as pass that removes variables in the session initializer.
// This job is required with lifting variable passes. Originally, the session
// initializer function does assigning variables. However, the read-only
// variable assignments will be done via lifting variables pass by converting
// the read-only variables to constant ops, instead. This pass removes the