builder = builder.dns(Dns.SYSTEM)
    builder = builder.socketFactory(SocketFactory.getDefault())
    builder = builder.sslSocketFactory(localhost().sslSocketFactory(), localhost().trustManager)
    builder = builder.hostnameVerifier(OkHostnameVerifier)
    builder = builder.certificatePinner(CertificatePinner.DEFAULT)
    builder = builder.authenticator(Authenticator.NONE)

import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import okio.ByteString;

/**
 * Runs a MockWebServer on localhost and uses it as the backend to receive an OAuth session.
 *
 * <p>Clients should call {@link #start}, {@link #newAuthorizeUrl} and {@link #close} in that order.
 * Clients may request multiple sessions.
 */

    }

    @Test
    public void testCreateConnection() throws Exception {
        InetSocketAddress remote = new InetSocketAddress("localhost", 445);
        InetSocketAddress local = null;

        RdmaConnection connection = provider.createConnection(remote, local);
        assertNotNull(connection, "Connection should not be null");

	displayCreds bool

	// Credential expiry duration
	expiryDuration time.Duration

	// Bucket to list
	bucketToList string
)

func init() {
	flag.StringVar(&stsEndpoint, "sts-ep", "http://localhost:9000", "STS endpoint")
	flag.StringVar(&token, "t", "", "Token to use with AssumeRoleWithCustomToken STS API (required)")
	flag.StringVar(&roleArn, "r", "", "RoleARN to use with the request (required)")

        assertNotNull(Curl.post("http://api.example.com/v1/resource"));
        assertNotNull(Curl.put("ftp://files.example.com/upload"));
        assertNotNull(Curl.delete("http://localhost:8080/delete"));
        assertNotNull(Curl.head("https://cdn.example.com/assets/file.js"));
        assertNotNull(Curl.options("http://cors.example.com/api"));
        assertNotNull(Curl.connect("http://proxy.example.com:3128"));

        <ul id='messages'>
        </ul>
        <script>
            var client_id = Date.now()
            document.querySelector("#ws-id").textContent = client_id;
            var ws = new WebSocket(`ws://localhost:8000/ws/${client_id}`);
            ws.onmessage = function(event) {
                var messages = document.getElementById('messages')
                var message = document.createElement('li')

package tests_test

import (
	"testing"

	"gorm.io/driver/mysql"

	"gorm.io/gorm"
)

func TestOpen(t *testing.T) {
	dsn := "gorm:gorm@tcp(localhost:9910)/gorm?loc=Asia%2FHongKong" // invalid loc
	_, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err == nil {
		t.Fatalf("should returns error but got nil")
	}
}

func TestReturningWithNullToZeroValues(t *testing.T) {
	dialect := DB.Dialector.Name()
	switch dialect {

     * @param localAddr the local address to bind to
     * @param localPort the local port to bind to
     * @throws IOException if an I/O error occurs while creating the socket
     */
    public NbtSocket(final NbtAddress address, final int port, final InetAddress localAddr, final int localPort) throws IOException {
        this(address, null, port, localAddr, localPort);
    }

    /**

import okhttp3.internal.DoubleInetAddressDns
import okhttp3.internal.connection.RealConnectionPool.Companion.get
import okhttp3.testing.Flaky
import okhttp3.testing.PlatformRule
import okhttp3.tls.internal.TlsUtil.localhost
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension

     * <ul>
     * <li>{@code *} (since 2.0.5)= everything,</li>
     * <li>{@code external:*}  (since 2.0.9)= everything not on the localhost and not file based,</li>
     * <li>{@code external:http:*} (since 3.8.0)= any repository not on the localhost using HTTP,</li>
     * <li>{@code repo,repo1}  (since 2.0.9)= {@code repo} or {@code repo1},</li>