}

                name = new Name( line.substring( i, j ), 0x20, null );
                addr = new NbtAddress( name, ip, false, NbtAddress.B_NODE,
                                    false, false, true, true,
                                    NbtAddress.UNKNOWN_MAC_ADDRESS );
                TAB.put( name, addr );
            }
        }
    }

            throw new IOException( "unexpected EOF reading netbios retarget session response" );
        }
        int addr = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        retargetAddress = new NbtAddress( null, addr, false, NbtAddress.B_NODE );
        retargetPort = readInt2( buffer, bufferIndex );
        return length;
    }

	}
	uid := string(pod.ObjectMeta.UID)

	add := &zdsapi.AddWorkload{
		WorkloadInfo: podToWorkload(pod),
		Uid:          uid,
	}
	r := &zdsapi.WorkloadRequest{
		Payload: &zdsapi.WorkloadRequest_Add{
			Add: add,
		},
	}
	log := log.WithLabels(
		"uid", add.Uid,
		"name", add.WorkloadInfo.Name,
		"namespace", add.WorkloadInfo.Namespace,
		"serviceAccount", add.WorkloadInfo.ServiceAccount,
	)

	fixture := getTestFixure(ctx)
	netServer := fixture.netServer
	ztunnelServer := fixture.ztunnelServer
	nlDeps := fixture.nlDeps
	pod := buildConvincingPod(false)
	// this is usually called after add. so manually add the pod uid for now
	fakens := newFakeNs(123)
	closed := fakens.closed
	workload := WorkloadInfo{
		Workload: podToWorkload(pod),
		Netns:    fakens,
	}

	t.Helper()
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener
	server.Start()
	// t.Cleanup(server.Close)
	t.Log("Started server on", server.Config.Addr, "URL:", server.URL)
	return server

				case reflect.Struct:
					reflectResults = reflect.Append(reflectResults, result.Addr())
				case reflect.Slice, reflect.Array:
					for i := 0; i < result.Len(); i++ {
						if elem := result.Index(i); elem.Kind() == reflect.Ptr {
							reflectResults = reflect.Append(reflectResults, elem)
						} else {
							reflectResults = reflect.Append(reflectResults, elem.Addr())
						}
					}
				}
			}
		}

		}
		return cmp.Compare(a.Hostname, b.Hostname)
	})
	fmt.Fprintln(w, "NAMESPACE\tSERVICE NAME\tSERVICE VIP\tWAYPOINT\tENDPOINTS")

	for _, svc := range svcs {
		ips := []string{}
		for _, addr := range svc.Addresses {
			_, ip, _ := strings.Cut(addr, "/")
			ips = append(ips, ip)
		}
		allEndpoints := len(svc.Endpoints)
		healthyEndpoints := 0
		for _, ep := range svc.Endpoints {
			w, f := workloadsByUID[ep.WorkloadUID]
			if !f {

        buf.dec_ndr_short(); /* max receive frag size */
        buf.dec_ndr_long();  /* assoc. group */
        int n = buf.dec_ndr_short(); /* secondary addr len */
        buf.advance(n); /* secondary addr */
        buf.align(4);
        buf.dec_ndr_small(); /* num results */
        buf.align(4);
        result = buf.dec_ndr_short();
        buf.dec_ndr_short();

        return this.nscl.getNbtAllByAddress(host, type, scope);
    }


    @Override
    public NetbiosAddress[] getNbtAllByAddress ( NetbiosAddress addr ) throws UnknownHostException {
        return this.nscl.getNbtAllByAddress(addr);
    }


    @Override
    public NetbiosName getLocalName () {
        return this.nscl.getLocalName();
    }


    @Override

			}
		}
	}
}

func TestSameLocalAddrs(t *testing.T) {
	testCases := []struct {
		addr1       string
		addr2       string
		sameAddr    bool
		expectedErr error
	}{
		{"", "", false, errors.New("unable to process empty address")},
		{":9000", ":9000", true, nil},
		{"localhost:9000", ":9000", true, nil},