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.");

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);

            }
        }
    }

        when:
        def reason = ComponentSelectionReasons.of(new DefaultComponentSelectionDescriptor(ComponentSelectionCause.REQUESTED), new DefaultComponentSelectionDescriptor(ComponentSelectionCause.FORCED))

        then:
        !reason.isExpected()
    }

    def addCause(ComponentSelectionReason reason, ComponentSelectionCause cause, String description) {

            }
            configurations {
                conf
                forced {
                    extendsFrom conf
                }
                substituted {
                    extendsFrom conf
                }
            }
            configurations.forced.resolutionStrategy.force 'org:leaf:1.0'
            configurations.substituted.resolutionStrategy.dependencySubstitution {

    }

    public void stopped(DaemonStopState stopState) {
        this.stopState.set(stopState);
    }

    @Override
    public void close() {
        if (stopState.get() == DaemonStopState.Forced) {
            // The daemon could not be stopped cleanly, so the services could still be doing work.
            // Don't attempt to stop the services, just stop this process
            return;
        }