vol3          = "vol3"
	pvcClaimName0 = "pvc-fake0"
	pvcClaimName1 = "pvc-fake1"
)

var (
	ErrorWatchTimeout = errors.New("watch event timeout")
	// Create pod spec to test against
	podVolumes = []k8sv1.Volume{
		{
			Name: vol0,
			VolumeSource: k8sv1.VolumeSource{
				GCEPersistentDisk: &k8sv1.GCEPersistentDiskVolumeSource{
					PDName: "fake-device1",
				},
			},
		},
		{
			Name: vol1,

		}

	case asmArray:
		tu := t.Underlying().(*types.Array)
		elem := tu.Elem()
		// Calculate offset of each element array.
		fields := []*types.Var{
			types.NewVar(token.NoPos, nil, "fake0", elem),
			types.NewVar(token.NoPos, nil, "fake1", elem),
		}
		offsets := arch.sizes.Offsetsof(fields)
		elemoff := int(offsets[1])
		for i := 0; i < int(tu.Len()); i++ {

}

// UpdateVirtualServer is a fake implementation, it updates the VirtualServer in the cache store.
func (f *FakeIPVS) UpdateVirtualServer(serv *utilipvs.VirtualServer) error {
	if serv == nil {
		return fmt.Errorf("failed to update service, service can't be nil")
	}
	key := toServiceKey(serv)
	f.Services[key] = serv
	return nil
}

func NewFake() *FakeInterface {
	fake := &FakeInterface{}
	fake.Reset()
	return fake
}

// Reset clears fake's sets/maps
func (fake *FakeInterface) Reset() {
	fake.ClearedIPs = sets.New[string]()
	fake.ClearedPorts = sets.New[int]()
	fake.ClearedNATs = make(map[string]string)
	fake.ClearedPortNATs = make(map[int]string)
}

// ClearEntriesForIP is part of Interface

	}
	sb.WriteString("]")
	return sb.String()
}

func (wgc *waitGroupCounter) Wait() {
	wgc.wg.Wait()
}

// Fake is one whose time does not pass implicitly but
// rather is explicitly set by invocations of its SetTime method.
// Each Fake has an associated GoRoutineCounter that is
// used to track associated activity.
// For the EventAfterDuration and EventAfterTime methods,

// limitations under the License.

package multicluster

import (
	"istio.io/istio/pkg/cluster"
	"istio.io/istio/pkg/kube"
)

type Fake struct {
	handlers []handler
}

func (f *Fake) registerHandler(h handler) {
	f.handlers = append(f.handlers, h)
}

func (f *Fake) Add(id cluster.ID, client kube.Client, stop chan struct{}) {
	for _, handler := range f.handlers {
		handler.clusterAdded(&Cluster{
			ID:            id,

See the License for the specific language governing permissions and
limitations under the License.
*/

package fake

import (
	auditinternal "k8s.io/apiserver/pkg/apis/audit"
	"k8s.io/apiserver/pkg/audit"
)

var _ audit.Backend = &Backend{}

// Backend is a fake audit backend for testing purposes.
type Backend struct {
	OnRequest func(events []*auditinternal.Event)
}

// Run does nothing.

		objects = append(objects, o)
	}
	return objects, nil
}

// DisableAuthorizationForSecret makes the authorization check always pass. Should be used only for tests.
func DisableAuthorizationForSecret(fake *fake.Clientset) {
	fake.Fake.PrependReactor("create", "subjectaccessreviews", func(action k8stesting.Action) (bool, runtime.Object, error) {
		return true, &authorizationv1.SubjectAccessReview{
			Status: authorizationv1.SubjectAccessReviewStatus{

	Version string
	// The key of Sets map is the ip set name
	Sets map[string]*ipset.IPSet
	// The key of Entries map is the ip set name where the entries exists
	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),
	}
}

	return false
}

func (f FakeEnvironment) IsMultiNetwork() bool {
	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++ {