// See the License for the specific language governing permissions and
// limitations under the License.

[[resolution-strategy-safety-nets]]
= Preventing accidental dependency upgrades

In some situations, you might want to be in total control of the dependency graph.
In particular, you may want to make sure that:

- the versions declared in a build script actually correspond to the ones being resolved

  bool IsAbsolutePath() const;

 private:
  // Replaces multiple consecutive separators with a single separator.
  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
  // redundancies that might be in a pathname involving "." or "..".
  //
  // A pathname with multiple consecutive separators may occur either through
  // user error or as a result of some scripts or APIs that generate a pathname

The Gradle team uses ADRs to record architectural decisions that the team has made.

See [Architecture decisions records](standards) for the list of ADRs.
Be aware these are very technical descriptions of the decisions, and you might find the documentation below more useful as an introduction to the internals of Gradle.

## Platform architecture

Gradle is arranged into several coarse-grained components called "platforms".

        fixture.assertStateStored {
            projectConfigured(":")
            modelsCreated(":", 3)
        }

        and:
        (model.left as GradleProject).name == "hello-world"
        (model.right as EclipseProject).gradleProject.name == "hello-world"

        and:
        def streamedModels = listener1.models as List<CustomModel>
        streamedModels.size() == 2
        streamedModels[0].value == 1

        @Override
        public int compare(ResolvableSelectorState left, ResolvableSelectorState right) {
            if (right.isProject() == left.isProject()) {
                if (right.isFromLock() == left.isFromLock()) {
                    if (hasLatestSelector(right) == hasLatestSelector(left)) {
                        if (isDynamicSelector(right) == isDynamicSelector(left)) {

            // Empty path, might match when more elements added
            return true;
        }
        if (!step.matches(segments[startIndex])) {
            // Does not match element, will never match when more elements added
            return false;
        }
        if (startIndex +1 == segments.length) {
            // End of path, might match when more elements added
            return true;

    GRACEFUL_EXPIRE,
    IMMEDIATE_EXPIRE;

    public static DaemonExpirationStatus highestPriorityOf(DaemonExpirationStatus left, DaemonExpirationStatus right) {
        if (left.ordinal() > right.ordinal()) {
            return left;
        } else {
            return right;
        }
    }

package org.sample.numberutils;

public class Numbers {
   public static int add(int left, int right) { return left + right; }

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

abstract class AbstractNativeLanguageComponentIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {

    def "binaries have the right platform type"() {
        given:
        makeSingleProject()
        buildFile << """
            task verifyBinariesPlatformType {
                doLast {

public class ModelRuleSourceDetector {

    private static final Comparator<Class<?>> COMPARE_BY_CLASS_NAME = new Comparator<Class<?>>() {
        @Override
        public int compare(Class<?> left, Class<?> right) {
            return left.getName().compareTo(right.getName());
        }
    };

    final LoadingCache<Class<?>, Collection<Reference<Class<? extends RuleSource>>>> cache = CacheBuilder.newBuilder()
            .weakKeys()