Entries map[string]sets.String
}

// NewFake create a new fake ipset interface - it initialize the FakeIPSet.
func NewFake(version string) *FakeIPSet {
	return &FakeIPSet{
		Version: version,
		Sets:    make(map[string]*ipset.IPSet),
		Entries: make(map[string]sets.String),
	}
}

// GetVersion is part of interface.
func (f *FakeIPSet) GetVersion() (string, error) {

	return false
}

func (f FakeEnvironment) EnvironmentName() string {
	if len(f.Name) == 0 {
		return "fake"
	}
	return f.Name
}

func (f FakeEnvironment) AllClusters() cluster.Clusters {
	res := cluster.Clusters{}
	allClusters := make(cluster.Map)

	for i := 0; i < f.NumClusters; i++ {
		topo := cluster.NewTopology(cluster.Config{
			Name:               fmt.Sprintf("cluster-%d", i),

	IsIPv6 bool
}

// NewFakeNetlinkHandle will create a new FakeNetlinkHandle
func NewFakeNetlinkHandle(isIPv6 bool) *FakeNetlinkHandle {
	fake := &FakeNetlinkHandle{
		localAddresses: make(map[string][]string),
		IsIPv6:         isIPv6,
	}
	return fake
}

// EnsureAddressBind is a mock implementation
func (h *FakeNetlinkHandle) EnsureAddressBind(address, devName string) (exist bool, err error) {

		ServiceEntryRegistry: se,
	}
	if !opts.SkipRun {
		fake.Run()
		if err := env.InitNetworksManager(xdsUpdater); err != nil {
			t.Fatal(err)
		}
		if err := env.PushContext().InitContext(env, nil, nil); err != nil {
			t.Fatalf("Failed to initialize push context: %v", err)
		}
	}
	return fake
}

func (f *ConfigGenTest) Run() {
	go f.Registry.Run(f.stop)

bootgo=1.20.6

set -e

if [[ ! -f run.bash ]]; then
	echo 'make.bash must be run from $GOROOT/src' 1>&2
	exit 1
fi

if [[ "$GOBUILDTIMELOGFILE" != "" ]]; then
	echo $(LC_TIME=C date) start make.bash >"$GOBUILDTIMELOGFILE"
fi

# Test for Windows.
case "$(uname)" in
*MINGW* | *WIN32* | *CYGWIN*)
	echo 'ERROR: Do not use make.bash to build on Windows.'
	echo 'Use make.bat instead.'
	echo
	exit 1
	;;
esac

goto fail
L155:del .\cmd\dist\dist.exe
L156:goto :eof
L157:
L158::: DO NOT ADD ANY NEW CODE HERE.
L159::: The bootstrap+del above are the final step of make.bat.
L160::: If something must be added, add it to cmd/dist's cmdbootstrap,
L161::: to avoid needing three copies in three different shell languages
L162::: (make.bash, make.bat, make.rc).
L163:
L164::copydist
L165:mkdir "%GOTOOLDIR%" 2>NUL
L166:copy cmd\dist\dist.exe "%GOTOOLDIR%\"
L167:goto :eof
L168:
L169::nogoenv
L170:set GO111MODULE=off
...

# (make.bash, make.bat, make.rc)....

	}
	cleanupStop := false
	stop := opts.Stop
	if stop == nil {
		// If we created the stop, clean it up. Otherwise, caller is responsible
		cleanupStop = true
		stop = make(chan struct{})
	}
	f := namespace.NewDiscoveryNamespacesFilter(
		kclient.New[*corev1.Namespace](opts.Client),
		opts.MeshWatcher,
		stop,
	)
	kubelib.SetObjectFilter(opts.Client, f)

	oldTable, err := f.Dump.GetTable(newTable.Name)
	if err != nil {
		return err
	}

	backupChains := make([]Chain, len(oldTable.Chains))
	copy(backupChains, oldTable.Chains)

	// Update internal state
	if flush == iptables.FlushTables {
		oldTable.Chains = make([]Chain, 0, len(newTable.Chains))
	}
	for _, newChain := range newTable.Chains {

Jefftree <******@****.***> 1705698827 -0500