when(mockInetAddress.getHostName()).thenReturn("myhost.domain.com");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("MYHOST", uniAddress.firstCalledName());
        }

        @Test

                return "fess-server";
            }
        });
        try {
            envMap.put("HOSTNAME", "myhost");
            final long pid = ProcessHandle.current().pid();
            assertEquals("fess-server@myhost:" + pid, systemHelper.getInstanceId());
        } finally {
            envMap.remove("HOSTNAME");
        }
    }

    @Test

		types := madmin.MetricsCPU

		m := collectLocalMetrics(types, collectMetricsOpts{
			hosts: map[string]struct{}{
				globalLocalNodeName: {},
			},
		})

		for _, hm := range m.ByHost {
			if hm.CPU != nil {
				v = *hm.CPU
				break
			}
		}

		return v, err
	}

	return cachevalue.NewFromFunc(1*time.Minute,
		cachevalue.Opts{ReturnLastGood: true},
		loadCPUMetrics)

		mRemote := collectRemoteMetrics(cctx, types, collectMetricsOpts{})
		cancel()
		m.Merge(&mRemote)
		for idx, host := range m.Hosts {
			m.Hosts[idx] = anonAddr(host)
		}
		for host, metrics := range m.ByHost {
			m.ByHost[anonAddr(host)] = metrics
			delete(m.ByHost, host)
		}
		return &m
	}

	anonymizeCmdLine := func(cmdLine string) string {
		if anonParam != anonymizeStrict {

		} else {
			stats := gr.ConnStats()
			m.Aggregated.RPC = &stats
		}
	}
	// Add types...

	// ByHost is a shallow reference, so careful about sharing.
	m.ByHost = map[string]madmin.Metrics{byHostName: m.Aggregated}
	m.Hosts = append(m.Hosts, byHostName)

	return m
}

	resource, err := getResource(r.URL.Path, r.Host, globalDomainNames)
	if err != nil {
		return nil
	}
	bucket, _ := path2BucketObject(resource)
	_, redirect := redirectPrefixes[path.Clean(bucket)]
	if redirect || resource == slashSeparator {
		if globalBrowserRedirectURL != nil {
			return globalBrowserRedirectURL
		}
		xhost, err := xnet.ParseHost(r.Host)
		if err != nil {
			return nil
		}

    assertThat(parse("http:\\\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:///host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\//host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:/\\/host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http://\\host/path"))

        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());

        // Test first host
        NbtAddress result = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result);
        assertEquals("TESTHOST", result.getHostName());

        // Test second host
        result = lmhosts.getByName("SERVER01", mockContext);
        assertNotNull(result);

            } 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) {

        when(transport.isDisconnected()).thenReturn(false);
        when(transport.getRemoteHostName()).thenReturn("host");
        setTree(c, tree);

        SmbResourceLocatorImpl loc = new SmbResourceLocatorImpl(ctx, smbUrl("smb://host/share/"));
        SmbTreeHandle h = c.connect(loc);
        assertNotNull(h);
        // No host connect attempted as we're already connected
        verify(c, never()).connectHost(any(), anyString());
    }