{
			name: "nodes present in lister",
			initialInformerNodes: []*v1.Node{
				testutil.NewNode("existing1"),
				testutil.NewNode("existing2"),
			},
			delay: 2 * quarantineTime,
			pods: []*v1.Pod{
				makePod("a", "existing1", v1.PodRunning),
				makePod("b", "existing2", v1.PodFailed),
				makePod("c", "existing2", v1.PodSucceeded),
			},
			itemsInQueue: 0,
		},
		{
			name: "nodes present in client",

        (Map<?, ?>) map == [existing: 'newValue', other: 'otherValue']
    }

    def "method replaceAll reports access to every item"() {
        when:
        getMapUnderTestToWrite().replaceAll((k, v) -> {
            if (k == 'existing') {
                return 'newValue'
            }
            return v
        })

        then:
        1 * onAccess.accept('existing', 'existingValue')

	}{
		{
			testName:      "no existing endpoints",
			serviceName:   "foo",
			ip:            "1.2.3.4",
			endpointPorts: []corev1.EndpointPort{{Name: "foo", Port: 8080, Protocol: "TCP"}},
			initialState:  nil,
			expectCreate:  makeEndpointsArray("foo", []string{"1.2.3.4"}, []corev1.EndpointPort{{Name: "foo", Port: 8080, Protocol: "TCP"}}),
		},
		{
			testName:      "existing endpoints satisfy",
			serviceName:   "foo",

		expectedSync: false,
	},
	{ // 2. existing object replication config enabled, no versioning
		name:         "existing object replication config enabled, no versioning",
		info:         ObjectInfo{Size: 100},
		rcfg:         replicationConfig{Config: &configs[0]},
		expectedSync: false,
	},
	{ // 3. existing object replication config enabled, versioning suspended

		Reason:  reason,
		Message: message,
	}
}

func TestSync(t *testing.T) {
	tests := []struct {
		name string

		in                            *apiextensionsv1.CustomResourceDefinition
		existing                      []*apiextensionsv1.CustomResourceDefinition
		expectedNames                 apiextensionsv1.CustomResourceDefinitionNames
		expectedNameConflictCondition apiextensionsv1.CustomResourceDefinitionCondition

	existing.Spec = ref.Spec
	existing.Labels = ref.Labels
	existing.DeletionTimestamp = ref.DeletionTimestamp
	existing.DeletionGracePeriodSeconds = ref.DeletionGracePeriodSeconds
	existing.Status = ref.Status
	updateAnnotations(existing, ref)

	// 2. this is an graceful delete
	if ref.DeletionTimestamp != nil {

			},
			allocatedCIDRs:        nil,
			expectedAllocatedCIDR: nil,
			ctrlCreateFail:        true,
		},
		{
			description: "fail, dualstack node allocating from non existing cidr",

			fakeNodeHandler: &testutil.FakeNodeHandler{
				Existing: []*v1.Node{
					{
						ObjectMeta: metav1.ObjectMeta{
							Name: "node0",
						},
						Spec: v1.NodeSpec{
							PodCIDRs: []string{"10.10.0.1/24", "a00::/86"},

                    Object key = getPluginKey().apply(element);
                    Plugin existing = master.get(key);
                    if (existing != null) {
                        existing = mergePlugin(existing, element, sourceDominant, context);
                        master.put(key, existing);
                        if (!pending.isEmpty()) {
                            predecessors.put(key, pending);

			chainedCNIPlugin: true,
		},
		{
			name:              "specified existing CNI config file",
			chainedCNIPlugin:  true,
			specifiedConfName: "list.conflist",
			expectedConfName:  "list.conflist",
			existingConfFiles: []string{"bridge.conf", "list.conflist"},
		},
		{
			name:              "specified existing CNI config file (.conf to .conflist)",
			chainedCNIPlugin:  true,

        then:
        result
        1 * listener.onAccess(EXISTING_KEY, EXISTING_VALUE)
        1 * listener.onAccess('existing', 'existingStringValue')
        1 * listener.onAccess('keyWithNonStringValue', NON_STRING_VALUE)
        1 * listener.onRemove(EXISTING_KEY)
        1 * listener.onRemove('existing')
        1 * listener.onRemove('keyWithNonStringValue')