"k8s.io/kubernetes/pkg/volume/csimigration"
	volumeutil "k8s.io/kubernetes/pkg/volume/util"
)

const pluginNameNotAvailable = "N/A"

const (
	// Force detach reason is timeout
	ForceDetachReasonTimeout = "timeout"
	// Force detach reason is the node has an out-of-service taint
	ForceDetachReasonOutOfService = "out-of-service"
	attachDetachController        = "attach_detach_controller"
)

var (

    private final static String SUPPRESSION = "enforced-platform";
    private final static String LONG_EXPLANATION = "In general publishing dependencies to enforced platforms is a mistake: " +
        "enforced platforms shouldn't be used for published components because they behave like forced dependencies and leak to consumers. " +
        "This can result in hard to diagnose dependency resolution errors.";

    Type quantizedType = converter.convert(elementType);
    assert(quantizedType &&
           "Converter accepted a type that it did not convert");

    // TODO: Map to a qbarrier with an attribute like [Forced] to signal that
    // this is a forced/hard-coded constraint.
    auto qbarrier = rewriter.create<QuantizeCastOp>(op.getLoc(), quantizedType,
                                                    op.getInputs());

            "org.codehaus.groovy:groovy-all"
        ],
        "selected": "org.codehaus.groovy:groovy"
    },

    // forced upgrade: the following modules will automatically be replaced with the selected module
    // even if there's no conflict, and forces an upgrade to the specified version
    {
        "name": "asm",
        "providedBy": [
            "asm:asm", "asm:asm-all", "asm:asm-debug-all"

        _ * details.getOldRequested() >> requested
        1 * details.useTarget(DefaultModuleComponentSelector.newSelector(mid(requested.group, requested.name), forcedVersion), ComponentSelectionReasons.FORCED)
        0 * details._

        where:
        requested                                            | forcedVersion
        newSelector(mid("org", "module2"), "0.9")            | "2.0"

            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        noExceptionThrown()
    }

    def "can cancel build through forced stop"() {
        // in-process call does not support forced stop
        toolingApi.requireDaemons()
        buildFile << """
task hang {
    doLast {
        ${server.callFromBuild("waiting")}
    }
}
"""

                            return DaemonStopState.Forced;
                    }
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
            LOGGER.debug("Cancel: daemon is still busy after grace period. Will force stop.");

 * </ul>
 * One value is used for derivation. A {@code platform} variant can be consumed as a {@code enforced-platform} which means all the dependency
 * information it provides is applied as {@code forced}.
 *
 * @since 5.3
 */
@UsedByScanPlugin
public interface Category extends Named {

import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.CONSTRAINT;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.FORCED;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.REQUESTED;

class DependencyState {
    private final ComponentSelector requested;

                details.useTarget(newSelector(key, versionConstraint, selector.getAttributes(), selector.getRequestedCapabilities()), ComponentSelectionReasons.FORCED);

            }
        }
    }