*
 *
 *  * <b>About NetBIOS:</b> The NetBIOS name
 * service is a dynamic distributed service that allows hosts to resolve
 * names by broadcasting a query, directing queries to a server such as
 * Samba or WINS. NetBIOS is currently the primary networking layer for
 * providing name service, datagram service, and session service to the
 * Microsoft Windows platform. A NetBIOS name can be 15 characters long

        }

        final String server = path.substring(1, s1).toLowerCase(Locale.ROOT);
        final String share = path.substring(s1 + 1, s2);
        String key = path.substring(0, dr.getPathConsumed()).toLowerCase(Locale.ROOT);

        final DfsReferralDataInternal dri = (DfsReferralDataInternal) dr;

        if (tc.getConfig().isDfsConvertToFQDN()) {
            dri.fixupHost(server);
        }

 *  * **[Hit Count:][hitCount]** the number of those requests whose responses were served by the
 *    cache.
 *
 * Sometimes a request will result in a conditional cache hit. If the cache contains a stale copy of
 * the response, the client will issue a conditional `GET`. The server will then send either
 * the updated response if it has changed, or a short 'not modified' response if the client's copy

        }
        this.server.securityMode = buffer[bufferIndex] & 0xFF;
        bufferIndex++;
        this.server.security = this.server.securityMode & 0x01;
        this.server.encryptedPasswords = (this.server.securityMode & 0x02) == 0x02;
        this.server.signaturesEnabled = (this.server.securityMode & 0x04) == 0x04;
        this.server.signaturesRequired = (this.server.securityMode & 0x08) == 0x08;

  fun multipleDnsLookupsForSingleCall() {
    server.enqueue(
      MockResponse
        .Builder()
        .code(301)
        .setHeader("Location", "http://www.fakeurl:" + server.port)
        .build(),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client

        }
        server.securityMode = buffer[bufferIndex] & 0xFF;
        bufferIndex++;
        server.security = server.securityMode & 0x01;
        server.encryptedPasswords = (server.securityMode & 0x02) == 0x02;
        server.signaturesEnabled = (server.securityMode & 0x04) == 0x04;
        server.signaturesRequired = (server.securityMode & 0x08) == 0x08;
        server.maxMpxCount = readInt2(buffer, bufferIndex);

    assertThat(webSocket.receivedPongCount()).isEqualTo(0)
    assertThat(server.sentPingCount()).isEqualTo(0)
    assertThat(server.receivedPingCount()).isEqualTo(0)
    assertThat(server.receivedPongCount()).isEqualTo(0)
    closeWebSockets(webSocket, server)
  }

  /**
   * Configure the websocket to send pings every 500 ms. Artificially prevent the server from

    assertConnectionNotReused(requestA, requestB)
  }

  @Test
  fun connectionsAreNotReusedWithResponseConnectionClose() {
    server.enqueue(
      MockResponse(
        headers = headersOf("Connection", "close"),
        body = "a",
      ),
    )
    server.enqueue(MockResponse(body = "b"))
    val requestA = Request(server.url("/"))
    val requestB = Request(server.url("/"))

    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test
  fun close() {
    client.webSocket!!.close(1000, "Hello!")
    // This will trigger a close response.
    assertThat(server.processNextFrame()).isFalse()
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    server.webSocket!!.close(1000, "Goodbye!")

### Server Binaries

filename | sha256 hash
-------- | -----------
[kubernetes-server-linux-amd64.tar.gz](https://dl.k8s.io/v1.4.12/kubernetes-server-linux-amd64.tar.gz) | `bf8aa3e2e204c1f782645f7df9338767daab7be3ab47a4670e2df08ee410ee7f`