t.Errorf("Expected Contains to return true for %v", contains)
				}
			}
			for _, notContains := range tc.notContains {
				if lister.Contains(notContains) != types.False {
					t.Errorf("Expected Contains to return false for %v", notContains)
				}
			}

			addition := UnstructuredToVal(tc.addition, tc.schema).(traits.Lister)
			added := lister.Add(addition).Value()

					t.Errorf("Expected Contains to return true for %v", contains)
				}
			}
			for _, notContains := range tc.notContains {
				if lister.Contains(notContains) != types.False {
					t.Errorf("Expected Contains to return false for %v", notContains)
				}
			}

			addition := UnstructuredToVal(tc.addition, tc.schema).(traits.Lister)
			added := lister.Add(addition).Value()

		first = first + 1
	})
	assert.NotContains(t, c.ListedPaths(), "/secret")
	assert.Contains(t, c.ListedPaths(), "/nonswagger")

	resp, _ := http.Get(s.URL + "/nonswagger")
	assert.Equal(t, first, 1)
	assert.Equal(t, resp.StatusCode, http.StatusOK)

	c.Unregister("/nonswagger")
	assert.NotContains(t, c.ListedPaths(), "/nonswagger")

	resp, _ = http.Get(s.URL + "/nonswagger")

		prefix      string
		ip          Addr
		bits        int
		str         string
		contains    []Addr
		notContains []Addr
	}{
		{
			prefix:      "192.168.0.0/24",
			ip:          mustIP("192.168.0.0"),
			bits:        24,
			contains:    mustIPs("192.168.0.1", "192.168.0.55"),
			notContains: mustIPs("192.168.1.1", "1.1.1.1"),
		},
		{
			prefix:      "192.168.1.1/32",

	as.Equal([]string{resourceName1}, removed)
	as.NotContains(capacity, v1.ResourceName(resourceName1))
	as.NotContains(allocatable, v1.ResourceName(resourceName1))
	val, ok := capacity[v1.ResourceName(resourceName2)]
	as.True(ok)
	as.Equal(int64(3), val.Value())
	as.NotContains(testManager.healthyDevices, resourceName1)
	as.NotContains(testManager.unhealthyDevices, resourceName1)
	as.NotContains(testManager.endpoints, resourceName1)

				}
			}
		default:
			outputStr := output.String()
			if tc.brokenCertName != "" {
				assert.Contains(t, outputStr, "!MISSING!")
			} else {
				assert.NotContains(t, outputStr, "!MISSING!")
			}

			var lines []string
			for _, line := range strings.SplitAfter(outputStr, "\n") {
				if strings.TrimSpace(line) != "" {
					lines = append(lines, line)
				}
			}

		for _, r := range resources {
			switch cgroupVersion {
			case cgroupV1:
				assert.Equal(t, int64(0), r.MemorySwapLimitInBytes, msg)
			case cgroupV2:
				assert.NotContains(t, r.Unified, cm.Cgroup2MaxSwapFilename, msg)
			}
		}
	}

	expectNoSwap := func(cgroupVersion CgroupVersion, resources ...*runtimeapi.LinuxContainerResources) {

	// That should mean no client actions were performed
	assert.Len(t, client.Actions(), 0)

	// TriggerTimeTracker should have removed the reference to the missing service
	assert.NotContains(t, esController.triggerTimeTracker.ServiceStates, missingServiceKey)

	// TriggerTimeTracker should have left the reference to the missing service

	// should only sync svc4, and shouldn't output its endpoints
	if numEndpoints != 0 {
		t.Errorf("Found wrong number of endpoints after service deletion: expected %d, got %d", 0, numEndpoints)
	}
	assert.NotContains(t, fp.iptablesData.String(), "-X ", "iptables data unexpectedly contains chain deletions")

	// But resyncing after a long-enough delay will delete the stale chains