serviceStore := serviceInformer.GetIndexer()
			err := serviceStore.Add(test.service)
			if err != nil {
				t.Fatalf("unexpected error adding service %v to the store: %v", test.service, err)
			}
			master.serviceLister = v1listers.NewServiceLister(serviceStore)
			master.client = fakeClient

		out = append(out, svcs...)
	}
	return model.SortServicesByCreationTime(out)
}

func (s *serviceStore) getServices(key types.NamespacedName) []*model.Service {
	return s.servicesBySE[key]
}

func (s *serviceStore) deleteServices(key types.NamespacedName) {
	delete(s.servicesBySE, key)
}

func (s *serviceStore) updateServices(key types.NamespacedName, services []*model.Service) {
	s.servicesBySE[key] = services

			Ports:     nil,
		},
	}

	controller.serviceStore.Add(svc)
	controller.onServiceUpdate(svc)
	// blockNextAction should eventually unblock once server gets endpoint request.
	waitForChanReceive(t, 1*time.Second, blockNextAction, "Service Add should have caused a request to be sent to the test server")

	controller.serviceStore.Delete(svc)
	controller.onServiceDelete(svc)

	existingServiceKey := endpointsliceutil.ServiceKey{Name: existingServiceName, Namespace: namespace}
	esController.triggerTimeTracker.ServiceStates[existingServiceKey] = endpointsliceutil.ServiceState{}
	esController.serviceStore.Add(&v1.Service{
		ObjectMeta: metav1.ObjectMeta{Name: existingServiceName, Namespace: namespace},
		Spec: v1.ServiceSpec{
			Ports:    []v1.ServicePort{{TargetPort: intstr.FromInt32(80)}},

	"k8s.io/kubernetes/pkg/registry/core/service/ipallocator"
)

var (
	serviceCIDRv4 = "10.0.0.0/16"
	serviceCIDRv6 = "2001:db8::/64"
)

type fakeRepair struct {
	*RepairIPAddress
	serviceStore     cache.Store
	ipAddressStore   cache.Store
	serviceCIDRStore cache.Store
}

func newFakeRepair() (*fake.Clientset, *fakeRepair) {
	fakeClient := fake.NewSimpleClientset()

var alwaysReady = func() bool { return true }

type endpointSliceMirroringController struct {
	*Controller
	endpointsStore     cache.Store
	endpointSliceStore cache.Store
	serviceStore       cache.Store
}

func newController(ctx context.Context, batchPeriod time.Duration) (*fake.Clientset, *endpointSliceMirroringController) {
	client := newClientset()

	"k8s.io/kubernetes/pkg/registry/core/service/portallocator"
	portallocatorcontroller "k8s.io/kubernetes/pkg/registry/core/service/portallocator/controller"
	servicestore "k8s.io/kubernetes/pkg/registry/core/service/storage"
	serviceaccountstore "k8s.io/kubernetes/pkg/registry/core/serviceaccount/storage"
	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"

	gotInstances = store.getAll()
	if len(gotInstances) != 0 {
		t.Errorf("got unexpected instances %v", gotSeInstances)
	}
}

func TestServiceStore(t *testing.T) {
	store := serviceStore{
		servicesBySE: map[types.NamespacedName][]*model.Service{},
	}

	expectedServices := []*model.Service{

	serviceInstances serviceInstancesStore
	// NOTE: historically, one index for both WorkloadEntry(s) and Pod(s);
	//       beware of naming collisions
	workloadInstances workloadinstances.Index
	services          serviceStore

	// To make sure the eds update run in serial to prevent stale ones can override new ones
	// when edsUpdate is called concurrently.

 * for their scope and its children.
 *
 * @see Scope
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface ServiceScope {

    /**
     * One or more scopes in which the service is declared,
     * from the longest lifecycle to the shortest.
     */
    Class<? extends Scope>[] value();