* </pre>
     */
    public void setRuleSets(List<String> ruleSets) {
        this.ruleSets.set(ruleSets);
    }

    /**
     * Convenience method for adding rule sets.
     *
     * <pre>
     *     ruleSets "category/java/errorprone.xml", "category/java/bestpractices.xml"
     * </pre>
     *
     * @param ruleSets the rule sets to be added
     */

public interface ProjectConnection extends Closeable {
    /**
     * Fetches a snapshot of the model of the given type for this project. This method blocks until the model is available.
     *
     * <p>This method is simply a convenience for calling {@code model(modelType).get()}</p>
     *
     * @param modelType The model type.
     * @param <T> The model type.
     * @return The model.

)

// All returns all analyzers
func All() []analysis.Analyzer {
	analyzers := []analysis.Analyzer{
		// Please keep this list sorted alphabetically by pkg.name for convenience
		&annotations.K8sAnalyzer{},
		&authz.AuthorizationPoliciesAnalyzer{},
		&deployment.ServiceAssociationAnalyzer{},
		&deployment.ApplicationUIDAnalyzer{},
		&deprecation.FieldAnalyzer{},

	Initialize(Capabilities{
		AllowPrivileged:                        allowPrivileged,
		PerConnectionBandwidthLimitBytesPerSec: perConnectionBytesPerSec,
	})
}

// SetForTests sets capabilities for tests.  Convenience method for testing.  This should only be called from tests.
func SetForTests(c Capabilities) {
	capInstance.lock.Lock()
	defer capInstance.lock.Unlock()
	capInstance.capabilities = &c
}

	// Allow flattening
	ao, ok := any(&a).(controllers.Object)
	if ok {
		k, _ := cache.MetaNamespaceKeyFunc(ao)
		return Key[O](k)
	}
	panic(fmt.Sprintf("Cannot get Key, got %T", a))
}

// Named is a convenience struct. It is ideal to be embedded into a type that has a name and namespace,
// and will automatically implement the various interfaces to return the name, namespace, and a key based on these two.
type Named struct {

     *
     * @since 4.5
     */
    void useTarget(Object notation, String reason);

    /**
     * Configures the artifact selection for the substitution.
     * This is a convenience method which allows selecting, typically, different artifact classifiers
     * for the same component.
     *
     * Artifact selection matters for components which are not published with Gradle Module Metadata

// so the implementation should preferably be constant-time.
typedef llvm::function_ref<llvm::SmallVector<Operation *, 4> const &(
    Operation *, bool incoming)>
    ExtraDependenciesFunction;

// Convenience function if there are no extra dependencies to declare.
// (Unlike nullptr, this also works inside the ternary operator)
extern ExtraDependenciesFunction no_extra_dependencies;

type PodSyncTarget interface {
	// AddPodSyncHandler adds the specified handler
	AddPodSyncHandler(a PodSyncHandler)
}

// PodLifecycleTarget groups a set of lifecycle interfaces for convenience.
type PodLifecycleTarget interface {
	PodAdmitTarget
	PodSyncLoopTarget
	PodSyncTarget
}

// PodAdmitHandlers maintains a list of handlers to pod admission.
type PodAdmitHandlers []PodAdmitHandler

 *              runs using the basic interface.
 */

CU_EXPORT void CU_basic_show_failures(CU_pFailureRecord pFailure);
/**<
 *  Prints a summary of run failures to stdout.
 *  This is provided for user convenience upon request, and does 
 *  not take into account the current run mode.  The failures are 
 *  printed to stdout independent of the most recent run mode.
 *
 *  @param pFailure List of CU_pFailureRecord's to output.

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Static convenience methods that serve the same purpose as Java language <a
 * href="https://docs.oracle.com/javase/8/docs/technotes/guides/language/assert.html">assertions</a>,