}

    @Test
    @DisplayName("Constructor should throw SmbException for non-workgroup type with host")
    void testConstructor_NonWorkgroupType_ThrowsException() throws Exception {
        // Given: A non-workgroup type with a host
        when(locator.getType()).thenReturn(SmbConstants.TYPE_SERVER);
        when(locator.getURL()).thenReturn(createSmbURL("smb://server/"));

            String remaining = urlStr.substring(6); // Remove "smb://"
            int slashIndex = remaining.indexOf('/');
            if (slashIndex == -1) {
                this.host = remaining;
                this.path = "/";
            } else {
                this.host = remaining.substring(0, slashIndex);
                this.path = remaining.substring(slashIndex);
            }

            // canonical form: remove . and .. but nothing fancy

        else -> ""
      }
    val effectiveHost =
      when {
        url.host.contains(":") -> "[" + url.host + "]"
        else -> url.host
      }
    assertThat(url.scheme, "scheme").isEqualTo(testData.scheme)
    assertThat(effectiveHost, "host").isEqualTo(testData.host)
    assertThat(effectivePort, "port").isEqualTo(testData.port)
    assertThat(url.encodedPath, "path").isEqualTo(testData.path)

    }

    /**
     * Constructs a NetBIOS session request packet.
     *
     * @param calledName the NetBIOS name of the called (destination) host
     * @param callingName the NetBIOS name of the calling (source) host
     */
    public SessionRequestPacket(final Name calledName, final Name callingName) {
        type = SESSION_REQUEST;
        this.calledName = calledName;
        this.callingName = callingName;
    }

    protected void parseURL(final URL u, String spec, final int start, int limit) {
        final String host = u.getHost();
        String path, ref;
        int port;

        if (spec.equals("smb1://")) {
            spec = "smb1:////";
            limit += 2;
        } else if (!spec.startsWith("smb1://") && host != null && host.length() == 0) {
            spec = "//" + spec;
            limit += 2;
        }

        // Act
        String result = smbTransport.getRemoteHostName();

        // Assert
        assertNotNull(result, "Remote host name should not be null");
        assertEquals(hostName, result, "Returned remote host name should be the mocked host name");
        verify(smbTransport).getRemoteHostName(); // Verify that the method was called
    }

  }

  @Test fun testHostname() {
    val headers = headersOf("Host", "host-from-header.com")
    val socket =
      MockWebServerSocket(
        FakeSocket(
          localAddress =
            InetAddress.getByAddress(
              "host-from-address.com",
              byteArrayOf(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1),
            ),

            } catch (final UnknownHostException uhe) {
                log.error("Unknown host " + addr, uhe);
            }
        }
        return def;
    }

    /**
     * Get the local host address based on the provided properties.
     *
     * @param props the properties to use for configuration
     * @return the local host InetAddress
     */
    public static InetAddress getLocalHost(final Properties props) {

Impone que todas las requests entrantes tengan correctamente configurado el header `Host`, para proteger contra ataques de HTTP Host Header.

{* ../../docs_src/advanced_middleware/tutorial002.py hl[2,6:8] *}

Se soportan los siguientes argumentos:

        throw UnknownServiceException("CLEARTEXT communication not enabled for client")
      }

      val host = route.address.url.host
      if (!Platform.get().isCleartextTrafficPermitted(host)) {
        throw UnknownServiceException(
          "CLEARTEXT communication to $host not permitted by network security policy",
        )
      }
    } else {