<artifactId>parent</artifactId>
    <version>11-SNAPSHOT</version>
  </parent>

  <groupId>inheritance</groupId>
  <artifactId>inheritance</artifactId>
  <version>11-SNAPSHOT</version>
  <name>Model urls inheritance test child</name>

  <scm child.scm.connection.inherit.append.path="true"
       child.scm.developerConnection.inherit.append.path="true"
       child.scm.url.inherit.append.path="true">

        mavenRepo.module("foo", "baz", "1.0").dependsOnModules("bar").publish()

        file("build.gradle") << """
            repositories {
                maven { url "${mavenRepo.uri}" }
            }
            configurations { foo }
            dependencies {
              foo 'i:dont:exist'
              foo 'foo:baz:1.0'
            }
        """

        when:

    }

    @Override
    public <T extends VersionControlSpec> DefaultVersionControlRepository create(Class<T> specType, URI uri) {
        return objectFactory.newInstance(DefaultVersionControlRepository.class, uri, notationParser, create(specType));
    }

     *
     * @see org.codelibs.robot.client.S2RobotClient#doGet(java.lang.String)
     */
    @Override
    public ResponseData doGet(final String uri) {
        return processRequest(uri, true);
    }

    protected ResponseData processRequest(final String uri, final boolean includeContent) {
        if (ftpAuthenticationHolder == null) {
            init();
        }

        // start

		{"Certificate.Signature", Field, 0},
		{"Certificate.SignatureAlgorithm", Field, 0},
		{"Certificate.Subject", Field, 0},
		{"Certificate.SubjectKeyId", Field, 0},
		{"Certificate.URIs", Field, 10},
		{"Certificate.UnhandledCriticalExtensions", Field, 5},
		{"Certificate.UnknownExtKeyUsage", Field, 0},
		{"Certificate.Version", Field, 0},
		{"CertificateInvalidError", Type, 0},

    }

    def "remote build cache configuration is exposed when basic auth is encoded on the url"() {
        given:
        httpBuildCacheServer.start()
        def safeUri = httpBuildCacheServer.uri
        def basicAuthUri = new URI(safeUri.getScheme(), 'user:pwd', safeUri.getHost(), safeUri.getPort(), safeUri.getPath(), safeUri.getQuery(), safeUri.getFragment())
        settingsFile << """
            buildCache {

        def scriptHandlerFactory = Mock(ScriptHandlerFactory)
        def gradleScope = Mock(ClassLoaderScope)
        def uri = new URI("file:///foo")
        def initScriptMock = Stub(ScriptSource) {
            getResource() >> Stub(TextResource) {
                getLocation() >> Stub(ResourceLocation) {
                    getURI() >> uri
                }
            }
        }
        def gradleMock = Mock(GradleInternal)

        executer.inDirectory(platformProject).withTasks('publish').run()

        settingsFile << """
            dependencyResolutionManagement {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }
                versionCatalogs {
                    libs {
                        from("org.gradle.test:my-platform:1.0")
                    }
                }
            }
        """

        }
        return null;
    }

    protected String preprocessUri(final String uri) {
        if (StringUtil.isEmpty(uri)) {
            throw new CrawlerSystemException("The uri is empty.");
        }

        String filePath = uri;
        if (!filePath.startsWith("storage:")) {
            filePath = "storage://" + filePath;
        }

        return filePath;

    }

    def canConstructResourceFromJarURI() {
        when:
        URI jarUri = createJar()
        UriTextResource resource = new UriTextResource('<display-name>', jarUri, resolver)

        then:
        resource.displayName == "<display-name> '$jarUri'"
        resource.file == null
        resource.charset == null
        resource.location.file == null
        resource.location.URI == jarUri
    }