// iteration variable of an enclosing loop, and the loop calls the function
// in such a way (e.g. with go or defer) that it may outlive the loop
// iteration and possibly observe the wrong value of the variable.
//
// Note: An iteration variable can only outlive a loop iteration in Go versions <=1.21.
// In Go 1.22 and later, the loop variable lifetimes changed to create a new

	t.Parallel()
	testChanSendBarrier(false)
}

func testChanSendBarrier(useSelect bool) {
	var wg sync.WaitGroup
	outer := 100
	inner := 100000
	if testing.Short() || runtime.GOARCH == "wasm" {
		outer = 10
		inner = 1000
	}
	for i := 0; i < outer; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			var garbage []byte
			for j := 0; j < inner; j++ {
				_, err := doRequest(useSelect)

        String opName = line.contains('"name": "allOf"') ?  'allOf' : 'anyOf'
        File outDir = opName == 'allOf' ? allOfDir : anyOfDir
        def sorted = sort(line)
        String opNameWithHash = "${opName}-${sorted.hashCode()}"

        Counter counter = opCounters[opNameWithHash]
        counter.inc()

        File mergeOp = new File(outDir, "${counter.formattedId}-${opName}-${counter.counter}.json")
        if (mergeOp.exists()) {

// be a *Trace struct.
type TraceKey struct{}

// LookupIPAltResolverKey is a context.Context Value key used by tests to
// specify an alternate resolver func.
// It is not exposed to outsider users. (But see issue 12503)
// The value should be the same type as lookupIP:
//
//	func lookupIP(ctx context.Context, host string) ([]IPAddr, error)
type LookupIPAltResolverKey struct{}

     *
     * ```
     * typealias Inner = String
     * typealias Outer = Inner
     *
     * val outer: Outer = ""
     * ```
     *
     * Here, `outer`'s type would be expanded to `String`, but its abbreviated type would be `Outer`. `Inner` would be lost.
     */
    public val abbreviatedType: KaUsualClassType?

class PreCreateOutputParentsStepTest extends StepSpec<ChangingOutputsContext> {
    def step = new PreCreateOutputParentsStep<>(delegate)

    def "outputs are created"() {
        given:
        def outputDir = file("outDir")
        def outputFile = file("parent/outFile")
        def localStateFile = file("local-state/stateFile")
        def destroyableFile = file("destroyable/file.txt")

        when:
        step.execute(work, context)

							<div class="alert alert-info">${msg}</div>
						</la:info>
						<la:errors />
					</div>
					<%-- Message: END --%>
					<div class="col-md-12">
						<div class="card card-outline card-primary">
							<div class="card-header">
								<h3 class="card-title">
									<la:message key="labels.upgrade_data_migration" />
								</h3>
							</div>
							<div class="card-body">

    @Test
    fun `version catalogs main extension is available`() {
        withKotlinBuildSrc()
        withSimpleVersionCatalog()
        val scriptBody = """
            // Can use outer build version catalog when applied
            println(versionCatalogs.named("libs").findLibrary("groovy").get().get())
        """
        withFile("buildSrc/src/main/kotlin/plugin-without-plugins.gradle.kts", scriptBody)

	// waiting for the first's call to f to complete.
	// This is why the slow path falls back to a mutex, and why
	// the o.done.Store must be delayed until after f returns.

	if o.done.Load() == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		o.doSlow(f)
	}
}

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	if o.done.Load() == 0 {
		defer o.done.Store(1)
		f()
	}

//
// `tags` identify the `tensorflow::MetaGraphDef` to load from the SavedModel.
// Similarly, `signature_keys` identify the functions (`SignatureDef`s) to load
// within the `MetaGraphDef`. `ctx` is the `MLIRContext`, which should outlive
// the returned `ModuleOp`, thus marked with the lifetime bound attribute.
// TODO: b/329206105 - Add unit tests after decomposing preprocessing passes.
absl::StatusOr<ImportedMlirModuleOp> SavedModelToMlirModuleOp(