.version("1")
                .build();

        assertNotNull(this.newModelResolver().resolveModel(session, parent, new AtomicReference<>()));
        assertEquals("1", parent.getVersion());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentUsingHighestVersion() throws Exception {
        final Parent parent = Parent.newBuilder()
                .groupId("org.apache")

    def "get version from json"() {
        when:
        def version = GradleVersionResolver.getVersion("""{ "version" : "7.6" }""", "latest")

        then:
        version == "7.6"
    }

    def "get version from empty json"() {
        when:
        def version = GradleVersionResolver.getVersion("{ }", "latest")

        then:
        def e = thrown(GradleException)

            return;
        }
        throw new UnsupportedJavaRuntimeException(String.format("%s %s requires Java %s or later to run. You are currently using Java %s.", component, GradleVersion.current().getVersion(),
            minVersion, current));
    }

    public static void assertUsingVersion(String component, int minVersion, int configuredVersion) throws UnsupportedJavaRuntimeException {

        public List<File> getIncludeDirs() {
            return Collections.singletonList(new File(getBaseDir(), "Include/" + getVersion() + "/ucrt"));
        }

        @Override
        public List<File> getLibDirs() {
            return Collections.singletonList(new File(getBaseDir(), "Lib/" + getVersion() + "/ucrt/" + platformDirName));
        }

        @Override
        public Map<String, String> getPreprocessorMacros() {

        if (capabilityVersions.size() > 1) {
            Set<Capability> sorted = Sets.newTreeSet((o1, o2) -> {
                VersionNumber v1 = VersionNumber.parse(o1.getVersion());
                VersionNumber v2 = VersionNumber.parse(o2.getVersion());
                return v2.compareTo(v1);
            });
            sorted.addAll(capabilityVersions);
            boolean first = true;

            File markerFile = getMarkerFile();

            if (!markerFile.exists() && logger.isLifecycleEnabled()) {
                logger.lifecycle("");
                logger.lifecycle("Welcome to Gradle " + gradleVersion.getVersion() + "!");

                String featureList = readReleaseFeatures();

                if (StringUtils.isNotBlank(featureList)) {
                    logger.lifecycle("");

        val sessionsBeforeModification = getSessions(ktModules)
        checkSessionValidityBeforeModification(sessionsBeforeModification, testServices)

        testServices.ktTestModuleStructure.publishWildcardModificationEventsByDirective(modificationEventKind)
        val sessionsAfterModification = getSessions(ktModules)

        val invalidatedSessions = buildSet {

        clone.setRelease(artifact.isRelease());
        clone.setResolvedVersion(artifact.getVersion());
        clone.setResolved(artifact.isResolved());
        clone.setFile(artifact.getFile());

        clone.setAvailableVersions(copyList(artifact.getAvailableVersions()));
        if (artifact.getVersion() != null) {
            clone.setBaseVersion(artifact.getBaseVersion());
        }

                return new VisualStudioMetadataBuilder()
                    .installDir(installDir)
                    .visualCppDir(visualCppMetadata.getVisualCppDir())
                    .visualCppVersion(visualCppMetadata.getVersion())
                    .compatibility(VisualStudioInstallCandidate.Compatibility.VS2017_OR_LATER)
                    .build();
            } else {
                File visualCppDir = new File(installDir, "VC");

        this.name = identifier.getName();
        this.version = identifier.getVersion();
    }

    @Override
    public String getGroup() {
        return group;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getVersion() {
        return version;
    }

    @Override
    public String toString() {