file.text = '<content>'

        UriTextResource resource = new UriTextResource('<display-name>', fileUri, resolver)

        then:
        resource.exists
        resource.text == '<content>'
        resource.asReader.text == '<content>'
    }

    def hasNoContentWhenUsingFileUriAndFileDoesNotExist() {
        when:
        UriTextResource resource = UriTextResource.from('<display-name>', file, resolver)

import java.io.Reader;
import java.net.URI;
import java.nio.charset.Charset;

/**
 * A {@link TextResource} implementation backed by a {@link UriTextResource}. This helps hide the internal details about file caching.
 */
public class DownloadedUriTextResource extends UriTextResource {

    private final String contentType;
    private final File downloadedResource;

        given:
        server.start()
        String unknownPath = '/unknown.txt'
        String fullURI = "${server.uri}${unknownPath}"
        UriTextResource resource = new UriTextResource('<display-name>', new URI(fullURI), new IdentityFileResolver())

        when:
        server.expect(server.get(unknownPath).missing())
        boolean exists = resource.exists

        then:

import java.io.File;
import java.io.Reader;
import java.io.StringReader;
import java.nio.charset.Charset;

/**
 * A {@link UriTextResource} that is empty and maps to an actual (non-null) file location
 * (which does not actually exist in the file system).
 */
public class EmptyFileTextResource extends UriTextResource {
    private static final HashCode SIGNATURE = Hashing.signature(EmptyFileTextResource.class);

import org.gradle.internal.resource.ResourceExceptions;
import org.gradle.internal.resource.TextResource;
import org.gradle.internal.resource.TextUriResourceLoader;
import org.gradle.internal.resource.UriTextResource;
import org.gradle.internal.resource.local.LocallyAvailableExternalResource;
import org.gradle.internal.resource.metadata.ExternalResourceMetaData;

import java.net.URI;
import java.util.Set;

import org.gradle.internal.exceptions.DefaultMultiCauseException
import org.gradle.internal.exceptions.LocationAwareException
import org.gradle.internal.file.RelativeFilePathResolver
import org.gradle.internal.resource.UriTextResource
import org.gradle.util.Path
import spock.lang.Specification

class ExceptionMetadataHelperTest extends Specification {

    void "extracts exception with multiple cause chain"() {
        given:

import org.gradle.api.credentials.PasswordCredentials
import org.gradle.internal.authentication.AllSchemesAuthentication
import org.gradle.internal.credentials.DefaultHttpHeaderCredentials
import org.gradle.internal.resource.UriTextResource
import spock.lang.Specification

class HttpClientConfigurerTest extends Specification {
    public static final String REMOTE_HOST = "host"
    public static final int SOME_PORT = 1234

 */

package org.gradle.internal.resource.transport.http;

import com.google.common.base.Charsets;
import org.gradle.api.resources.ResourceException;
import org.gradle.internal.resource.UriTextResource;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;

    @Override
    public TextResource loadFile(String description, @Nullable File sourceFile) {
        if (sourceFile == null) {
            return new StringTextResource(description, "");
        }
        return UriTextResource.from(description, sourceFile, resolver);
    }

            if (targetCharsetObj.equals(sourceCharset)) {
                return file;
            }

            File targetFile = tempFileProvider.createTemporaryFile("uriTextResource", ".txt", "resource");
            try {
                Files.asCharSource(file, sourceCharset).copyTo(Files.asCharSink(targetFile, targetCharsetObj));
                return targetFile;
            } catch (IOException e) {