server.useHttps(socketFactory)
    server.requestClientAuth()
    server.enqueue(
      MockResponse.Builder()
        .body("abc")
        .build(),
    )
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.handshake!!.peerPrincipal)
      .isEqualTo(X500Principal("CN=Local Host"))
    assertThat(response.handshake!!.localPrincipal)

type CNIEventClient struct {
	client *http.Client
	url    string
}

func buildClient(address, path string) CNIEventClient {
	c := &http.Client{
		Transport: &http.Transport{
			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
				return net.Dial("unix", address)
			},
		},
		Timeout: 5 * time.Second,
	}
	eventC := CNIEventClient{
		client: c,
		url:    "http://unix" + path,
	}
	return eventC
}

    state = STATE_READING_RESPONSE_BODY
    return FixedLengthSource(length)
  }

  private fun newChunkedSource(url: HttpUrl): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }
    state = STATE_READING_RESPONSE_BODY
    return ChunkedSource(url)
  }

  private fun newUnknownLengthSource(): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }

  <artifactId>maven-test-snapshot-resolving</artifactId>
  <packaging>jar</packaging>
  <repositories>
    <repository>
      <id>central</id>
      <name>Fake Maven Central Repository</name>
      <url>file://dummy</url>
    </repository>
  </repositories>
  <dependencies>
    <dependency>
      <groupId>snapshot-test</groupId>
      <artifactId>maven-snapshot-a</artifactId>
      <version>1.0-SNAPSHOT</version>

  </parent>
  <groupId>inheritance</groupId>
  <artifactId>child</artifactId>
  <version>1</version>
  <url></url>
  <scm>
    <connection></connection>
    <developerConnection></developerConnection>
    <url></url>
  </scm>
  <distributionManagement>
    <site>
      <url></url>
    </site>
  </distributionManagement>

package rest

import (
	"errors"
	"net"
	"net/url"
	"testing"
)

func TestNetworkError_Unwrap(t *testing.T) {
	tests := []struct {
		name   string
		err    error
		target interface{}
		want   bool
	}{
		{
			name:   "url.Error",
			err:    &url.Error{Op: "PUT", URL: "http://localhost/1234", Err: restError("remote server offline")},
			target: &url.Error{},
			want:   true,
		},
		{

      .build()

  fun run() {
    try {
      val request = Request(server.url("/"))

      client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")

        println(response.request.url)
      }
    } finally {
      server.shutdown()
    }
  }
}

fun main() {
  DevServer().run()

  <artifactId>project</artifactId>
  <version>1.0.0-SNAPSHOT</version>

  <properties>
    <x>just/some/path</x>
  </properties>

  <repositories>
    <repository>
      <id>repo</id>
      <url>file://${x}/sdk/maven/repo</url>
    </repository>
  </repositories>

		req.Header.Set("Expires", expiresStr)
	}

	// url.RawPath will be valid if path has any encoded characters, if not it will
	// be empty - in which case we need to consider url.Path (bug in net/http?)
	encodedResource := req.URL.RawPath
	encodedQuery := req.URL.RawQuery
	if encodedResource == "" {
		splits := strings.SplitN(req.URL.Path, "?", 2)
		encodedResource = splits[0]
		if len(splits) == 2 {

     * 
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get ( String url ) throws CIFSException {
        try {
            return new SmbFile(url, this);
        }
        catch ( MalformedURLException e ) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }


    /**
     * 
     * {@inheritDoc}
     *