*/
public abstract class KotlinModificationTrackerFactory : KotlinPlatformComponent {
    /**
     * Creates an out-of-block modification tracker which is incremented every time there is an out-of-block change in some source project
     * module.
     *
     * ### Out-of-block Modification (OOBM)
     *
     * Out-of-block modification is a source code modification which may change the resolution of other non-local declarations.
     *

        outputContains("files = [a.thing, b.thing, a.out, b.out, lib1-6500.jar]")
        outputContains("artifacts = [a.thing (a.thing), b.thing (b.thing), a.out (project :a), b.out (project :b), lib1-6500.jar (group:lib1:6500)]")
        outputContains("variants = [{artifactType=thing}, {artifactType=thing}, {artifactType=out}, {artifactType=out}, {artifactType=jar, org.gradle.status=release}]")

	// It must keep consuming from 'in' until it returns.
	// 'in' and 'out' are independent.
	// The handler should never close out.
	// Buffers received from 'in'  can be recycled with PutByteBuffer.
	// Buffers sent on out can not be referenced once sent.
	StreamHandlerFn func(ctx context.Context, payload []byte, in <-chan []byte, out chan<- []byte) *RemoteErr

	// StreamHandler handles fully bidirectional streams,

				} else {
					intersection = intersection.Intersection(t)
				}
			}
		}
		for name := range intersection {
			out[c.Name()].Insert(name)
		}
	}

	return out, nil
}

// build inner allows assigning to b (assignment to receiver would be ineffective)
func build(b *builder) (out echo.Instances, err error) {
	start := time.Now()
	scopes.Framework.Info("=== BEGIN: Deploy echo instances ===")
	defer func() {

			filteredWorkloads = append(filteredWorkloads, workload)
		}
	}
	out, err := json.MarshalIndent(filteredWorkloads, "", "    ")
	if err != nil {
		return fmt.Errorf("failed to marshal workloads: %v", err)
	}
	if outputFormat == "yaml" {
		if out, err = yaml.JSONToYAML(out); err != nil {
			return err
		}
	}
	fmt.Fprintln(c.Stdout, string(out))
	return nil
}

	_ = istiolog.Sync()

	// Restore os stdout.
	os.Stdout = stdout
	assert.NoError(t, istiolog.Configure(loggingOptions))

	assert.NoError(t, w.Close())
	out, err := io.ReadAll(r)
	assert.NoError(t, err)

	cases := []struct {
		level string
		msg   string
		key   *float64
	}{
		{"debug", "debug log", nil},
		{"info", "info log", nil},
		{"warn", "warn log", nil},

) : BuildTreeModelCreator {
    override fun <T : Any> beforeTasks(action: BuildTreeModelAction<out T>) {
        cache.maybePrepareModel {
            delegate.beforeTasks(action)
        }
    }

    override fun <T : Any?> fromBuildModel(action: BuildTreeModelAction<out T>): T? {
        return cache.loadOrCreateModel {
            val model = delegate.fromBuildModel(action)

    public val severity: KaSeverity

    public val defaultMessage: String
}

public typealias KtDiagnostic = KaDiagnostic

public interface KaDiagnosticWithPsi<out PSI : PsiElement> : KaDiagnostic {
    public override val diagnosticClass: KClass<out KaDiagnosticWithPsi<PSI>>

    public val psi: PSI
    public val textRanges: Collection<TextRange>
}

public typealias KtDiagnosticWithPsi<PSI> = KaDiagnosticWithPsi<PSI>

	for _, pod := range pods {
		out, err := yaml.Marshal(&pod)
		if err != nil {
			scopes.Framework.Warnf("Error marshaling pod state for output: %v", err)
			continue
		}

		outPath := podOutputPath(workDir, c, pod, "pod-state.yaml")
		if err := os.WriteFile(outPath, out, os.ModePerm); err != nil {
			scopes.Framework.Infof("Error writing out pod state to file: %v", err)
		}
	}
}

	h, f := cl.kind(kind)
	if !f {
		return nil
	}

	list := h.List(namespace, klabels.Everything())

	out := make([]config.Config, 0, len(list))
	for _, item := range list {
		cfg := TranslateObject(item, kind, cl.domainSuffix)
		out = append(out, cfg)
	}

	return out
}

func (cl *Client) allKinds() map[config.GroupVersionKind]kclient.Untyped {
	cl.kindsMu.RLock()
	defer cl.kindsMu.RUnlock()