}
  }

  public void testFromHost() {
    HostAndPort hp = HostAndPort.fromHost("gmail.com");
    assertEquals("gmail.com", hp.getHost());
    assertFalse(hp.hasPort());

    hp = HostAndPort.fromHost("[::1]");
    assertEquals("::1", hp.getHost());
    assertFalse(hp.hasPort());

    try {
      HostAndPort.fromHost("gmail.com:80");

	expire time.Time
	path   string
	mtime  time.Time
	size   int64
}

func readHosts() {
	now := time.Now()
	hp := hostsFilePath

	if now.Before(hosts.expire) && hosts.path == hp && len(hosts.byName) > 0 {
		return
	}
	mtime, size, err := stat(hp)
	if err == nil && hosts.path == hp && hosts.mtime.Equal(mtime) && hosts.size == size {
		hosts.expire = now.Add(cacheMaxAge)
		return
	}

			NodeRef: &v1.ObjectReference{
				Kind:      "Node",
				Name:      nodeName,
				UID:       types.UID(nodeName),
				Namespace: "",
			},
		},
	}
}

func (hp *HollowProxy) Run() error {

	if err := hp.ProxyServer.Run(context.TODO()); err != nil {
		return fmt.Errorf("Error while running proxy: %w", err)
	}
	return nil

}

// HTML returns an HTML formatting of the [Doc].
// See the [Printer] documentation for ways to customize the HTML output.
func (p *Printer) HTML(d *Doc) []byte {
	hp := &htmlPrinter{Printer: p}
	var out bytes.Buffer
	for _, x := range d.Content {
		hp.block(&out, x)
	}
	return out.Bytes()
}

// block prints the block x to out.
func (p *htmlPrinter) block(out *bytes.Buffer, x Block) {
	switch x := x.(type) {

        APPLE("apple", "Apple"),
        AZUL("azul systems", "Azul Zulu"),
        BELLSOFT("bellsoft", "BellSoft Liberica"),
        GRAAL_VM("graalvm community", "GraalVM Community"),
        HEWLETT_PACKARD("hewlett-packard", "HP-UX"),
        IBM("ibm", "ibm|international business machines corporation", "IBM"),
        JETBRAINS("jetbrains", "JetBrains"),
        MICROSOFT("microsoft", "Microsoft"),
        ORACLE("oracle", "Oracle"),

//       algorithm can be used to compute log1p(x) to within a few ULP:
//
//              u = 1+x;
//              if(u==1.0) return x ; else
//                         return log(u)*(x/(u-1.0));
//
//       See HP-15C Advanced Functions Handbook, p.193.

// Log1p returns the natural logarithm of 1 plus its argument x.
// It is more accurate than [Log](1 + x) when x is near zero.
//
// Special cases are:
//
//	Log1p(+Inf) = +Inf

00000100  cb 3b 74                                          |.;t|
>>> Flow 2 (server to client)
00000000  16 03 03 00 5d 02 00 00  59 03 03 8f cc 68 50 60  |....]...Y....hP`|
00000010  11 c8 c3 ce e7 e9 e1 3c  fb 29 d7 4f df 44 16 65  |.......<.).O.D.e|
00000020  1d 3b 25 5b 32 59 f1 8e  be d8 49 20 c2 89 a7 d5  |.;%[2Y....I ....|

00000420  09 68 14 9a 89 e0 6b ef  ac 90 27 69 2b 01 6c 2e  |.h....k...'i+.l.|
00000430  6d e9 26 9f b1 ff b8 6c  8b 33 bb e8 42 54 85 c9  |m.&....l.3..BT..|
00000440  14 d5 89 48 50 a6 8d be  dd b8 96 f1 45 4f 90 08  |...HP.......EO..|
00000450  da cf 1f 75 33 85 d9 be  8e a5 4a c5 be a9 a3 16  |...u3.....J.....|
00000460  f6 37 02 79 ea c3 e5 10  ed ff d5 f2 3d 46 7b ed  |.7.y........=F{.|