sel := call.Fun.(*syntax.SelectorExpr)
					use := info.Uses[sel.Sel].(*Func)
					selection := info.Selections[sel]
					if selection.Kind() != MethodVal {
						t.Errorf("Selection kind = %v, want %v", selection.Kind(), MethodVal)
					}
					if selection.Obj() != use {
						t.Errorf("info.Selections contains %v, want %v", selection.Obj(), use)
					}
					switch sel.Sel.Value {
					case "m":
						dmm = use

					sel := call.Fun.(*ast.SelectorExpr)
					use := info.Uses[sel.Sel].(*Func)
					selection := info.Selections[sel]
					if selection.Kind() != MethodVal {
						t.Errorf("Selection kind = %v, want %v", selection.Kind(), MethodVal)
					}
					if selection.Obj() != use {
						t.Errorf("info.Selections contains %v, want %v", selection.Obj(), use)
					}
					switch sel.Sel.Name {
					case "m":
						dmm = use

 * <pre>
 * TestLauncher testLauncher = projectConnection.newTestLauncher();
 * testLauncher.withTestsFor(specs -&gt; {
 *     specs.forTaskPath(":test")                                    // configure the test selection on the ':test' task
 *          .includePackage("org.pkg")                               // execute all tests declared the org.pkg package and its sub-packages

                }
                // The provider has GMM but we still allow classifier selection - even if the consumer has GMM as well.
                // Although it is discouraged to use this feature with GMM alone, the behavior is helpful, if a provider
                // starts publishing GMM but did not do so before.
                // Then consumers that use a classifier selection, do not suddenly break with a version upgrade that brings in GMM.

        NativeLanguage sourceLanguage = NativeLanguage.CPP;
        NativeToolChainInternal toolChain = getToolChain(sourceLanguage, targetNativePlatform);

        // TODO - don't select again here, as the selection is already performed to select the toolchain
        PlatformToolProvider toolProvider = toolChain.select(sourceLanguage, targetNativePlatform);

}

// Matcher returns a selection predicate for a given label and field selector.
func Matcher(label labels.Selector, field fields.Selector) pkgstorage.SelectionPredicate {
	return pkgstorage.SelectionPredicate{
		Label:    label,
		Field:    field,
		GetAttrs: GetAttrs,
	}
}

// SelectableFields returns a field set that can be used for filter selection
func SelectableFields(obj *api.Secret) fields.Set {

import java.util.List;

/**
 * A {@link ResolutionFailure} that represents the situation when multiple artifact transforms are
 * available that would satisfy a dependency selection request.
 */
public final class AmbiguousArtifactTransformFailure extends AbstractIncompatibleAttributesSelectionFailure {
    private final ImmutableList<TransformedVariant> transformedVariants;

    | org.gradle.dependency.bundling |          | external     |
    | org.gradle.jvm.environment     |          | standard-jvm |
    | org.gradle.jvm.version         |          | 11           |
   Selection reasons:
      - By conflict resolution: On capability log4j:log4j use slf4j in place of log4j

log4j:log4j:1.2.16 -> org.slf4j:log4j-over-slf4j:1.7.10
\--- org.apache.zookeeper:zookeeper:3.4.9
     \--- compileClasspath

        this.failureHandler = failureHandler;
    }

    /**
     * Returns the failure processor which must be used to report failures during variant selection.
     *
     * @return the failure processor
     */
    public ResolutionFailureHandler getFailureHandler() {
        return failureHandler;
    }

    public VariantGraphResolveState selectByAttributeMatching(

			// still require the field to be declared in the schema.
			//
			// Quoting from
			// https://github.com/google/cel-spec/blob/master/doc/langdef.md#field-selection
			//
			// To test for the presence of a field, the boolean-valued macro has(e.f) can be used.
			//
			// 2. If e evaluates to a message and f is not a declared field for the message,