handler := newFakeHandler()

	// 1. test no readyFunc
	if !handler.WaitForReady() {
		t.Errorf("Expect ready for no readyFunc provided.")
	}

	// 2. readyFunc return ready immediately
	readyFunc := func() bool {
		return true
	}
	handler.SetReadyFunc(readyFunc)
	if !handler.WaitForReady() {
		t.Errorf("Expect ready for readyFunc returns ready immediately.")
	}

	// 3. readyFunc always return not ready. WaitForReady timeout

	}
	return &Handler{
		operations: operations,
	}
}

// SetReadyFunc allows late registration of a ReadyFunc to know if the handler is ready to process requests.
func (h *Handler) SetReadyFunc(readyFunc ReadyFunc) {
	h.readyFunc = readyFunc
}

// WaitForReady will wait for the readyFunc (if registered) to return ready, and in case of timeout, will return false.
func (h *Handler) WaitForReady() bool {

func newPlugin() *classDefaulterPlugin {
	return &classDefaulterPlugin{
		Handler: admission.NewHandler(admission.Create),
	}
}

// SetExternalKubeInformerFactory sets a lister and readyFunc for this
// classDefaulterPlugin using the provided SharedInformerFactory.
func (a *classDefaulterPlugin) SetExternalKubeInformerFactory(f informers.SharedInformerFactory) {
	informer := f.Networking().V1().IngressClasses()

	}
	if got, want := *seven.(*int), 7; got != want {
		log.Fatalf("plugin1.Seven=%d, want %d", got, want)
	}

	readFunc, err := p.Lookup("ReadCommonX")
	if err != nil {
		log.Fatalf(`plugin1.Lookup("ReadCommonX") failed: %v`, err)
	}
	if got := readFunc.(func() int)(); got != wantX {
		log.Fatalf("plugin1.ReadCommonX()=%d, want %d", got, wantX)
	}

					pi, len(efuncs), nf)
			}
			var f coverage.FuncDesc
			for fi := 0; fi < int(nf); fi++ {
				if err := pd.ReadFunc(uint32(fi), &f); err != nil {
					t.Fatalf("ReadFunc(%d) pk %d got error %v",
						fi, pi, err)
				}
				res := cmpFuncDesc(efuncs[fi], f)
				if res != "" {
					t.Errorf("ReadFunc(%d) pk %d: %s", fi, pi, res)
				}
			}
		}
		inf.Close()
	}
}

	return d.strtab.Get(d.hdr.ModulePath)
}

func (d *CoverageMetaDataDecoder) NumFuncs() uint32 {
	return d.hdr.NumFuncs
}

// ReadFunc reads the coverage meta-data for the function with index
// 'findex', filling it into the FuncDesc pointed to by 'f'.
func (d *CoverageMetaDataDecoder) ReadFunc(fidx uint32, f *coverage.FuncDesc) error {
	if fidx >= d.hdr.NumFuncs {
		return fmt.Errorf("illegal function index")
	}

}

// isPredeclared reports whether n denotes a predeclared type.
func (r *reader) isPredeclared(n string) bool {
	return predeclaredTypes[n] && r.types[n] == nil
}

// readFunc processes a func or method declaration.
func (r *reader) readFunc(fun *ast.FuncDecl) {
	// strip function body if requested.
	if r.mode&PreserveAST == 0 {
		fun.Body = nil
	}

	// associate methods with the receiver type, if any

		}
		ts.cf.SetPackage(pd.PackagePath())
		importpaths[pd.PackagePath()] = struct{}{}
		var fd coverage.FuncDesc
		nf := pd.NumFuncs()
		for fnIdx := uint32(0); fnIdx < nf; fnIdx++ {
			if err := pd.ReadFunc(fnIdx, &fd); err != nil {
				return fmt.Errorf("reading meta-data file %s: %v",
					p.MetaFile, err)
			}
			key := pkfunc{pk: pkIdx, fcn: fnIdx}
			counters, haveCounters := pmm[key]

		if !r.matchpkg(pd.PackagePath()) {
			return nil
		}
	}
	r.vis.BeginPackage(pd, pkgIdx)
	nf := pd.NumFuncs()
	var fd coverage.FuncDesc
	for fidx := uint32(0); fidx < nf; fidx++ {
		if err := pd.ReadFunc(fidx, &fd); err != nil {
			return r.fatal("reading meta-data file %s: %v", mfname, err)
		}
		r.vis.VisitFunc(pkgIdx, fidx, &fd)
	}
	r.vis.EndPackage(pd, pkgIdx)
	return nil