r = ResyncDecision{
		targets: make(map[string]ResyncTargetDecision, len(dsc.targetsMap)),
	}
	if c.remotes == nil {
		return
	}
	for _, tgt := range c.remotes.Targets {
		d, ok := dsc.targetsMap[tgt.Arn]
		if !ok {
			continue
		}
		if !d.Replicate {
			continue
		}

	}
	// reset state
	podKiller.pod = nil
	podKiller.gracePeriodOverride = nil

	// remove memory pressure
	fakeClock.Step(20 * time.Minute)
	summaryProvider.result = summaryStatsMaker("3Gi", podStats)
	_, err = manager.synchronize(diskInfoProvider, activePodsFunc)

	if err != nil {

FastMap$EntryImpl before; void FastMap$EntrySet$1(FastMap$EntrySet); public void remove(); public boolean hasNext(); public Object next(); } org/codehaus/plexus/util/FastMap$EntrySet.class package org.codehaus.plexus.util; synchronized class FastMap$EntrySet extends java.util.AbstractSet { private void FastMap$EntrySet(FastMap); public java.util.Iterator iterator(); public int size(); public boolean contains(Object); public boolean remove(Object); } org/codehaus/plexus/util/FastMap$KeySet$1.class package or...

(NilCheck ptr:(SelectN [0] call:(StaticLECall _ _)) _)
	&& isSameCall(call.Aux, "runtime.newobject")
	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
	=> ptr

(NilCheck ptr:(OffPtr (SelectN [0] call:(StaticLECall _ _))) _)
	&& isSameCall(call.Aux, "runtime.newobject")
	&& warnRule(fe.Debug_checknil(), v, "removed nil check")
	=> ptr

// Addresses of globals are always non-nil.
(NilCheck          ptr:(Addr {_} (SB))    _) => ptr

		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}
		if !afterWasCalled {
			t.Errorf("unexpected, AfterDelete() was not called")
		}
		// the pod should be removed, because its finalizer is removed
		_, err = registry.Get(testContext, podWithFinalizer.Name, &metav1.GetOptions{})
		if !errors.IsNotFound(err) {
			t.Fatalf("Unexpected error: %v", err)
		}
	}
}

	err = expectSyncNotBlocked(fakeDiscoveryClient, &gc.workerLock)
	if err != nil {
		t.Fatalf("Expected garbagecollector.Sync to still be running but it is blocked: %v", err)
	}
	// Unsyncable monitor removed
	assertMonitors(t, gc, "pods", "deployments")
}

func assertMonitors(t *testing.T, gc *GarbageCollector, resources ...string) {
	t.Helper()
	expected := sets.NewString(resources...)
	actual := sets.NewString()

				st.MakePod().Name("p-b1").Node("node-b").Label("foo", "").Obj(),
				st.MakePod().Name("p-x1").Node("node-x").Label("foo", "").Obj(),
			},
			deletedPodIdx: 0, // remove pod "p-a1"
			nodeIdx:       0, // node-a
			want: &preFilterState{
				Constraints:       []topologySpreadConstraint{zoneConstraint},
				TpKeyToDomainsNum: map[string]int{"zone": 2},

				# TYPE kubelet_working_pods gauge
				kubelet_working_pods{config="desired",lifecycle="sync",static=""} 0

				testutil.CreateZoneID("region1", "zone1"): stateFullDisruption,
				testutil.CreateZoneID("region2", "zone2"): stateFullDisruption,
			},
		},
		"Full Disruption: Ready condition removed from the Node": {
			nodeList: []*v1.Node{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:              "node0",
						CreationTimestamp: fakeNow,
						Labels: map[string]string{

						},
					},
				},
			},
			wantErrs: field.ErrorList{
				{Type: field.ErrorTypeInvalid, Field: "status.conditions"},
			},
		},
		"completionTime can be removed to fix still running job": {
			enableJobManagedBy: true,
			job: &batch.Job{
				ObjectMeta: validObjectMeta,
				Status: batch.JobStatus{
					StartTime:      &now,
					CompletionTime: &now,
				},