func (p *podContainerDeletor) deleteContainersInPod(filterContainerID string, podStatus *kubecontainer.PodStatus, removeAll bool) {
	containersToKeep := p.containersToKeep
	if removeAll {
		containersToKeep = 0
		filterContainerID = ""
	}

	for _, candidate := range getContainersToDeleteInPod(filterContainerID, podStatus, containersToKeep) {
		select {

        when:
        collection.add("third")

        then:
        property.get() == cast(["first", "second", "forth", "fifth", "third"])
        collection.size() == 5

        when:
        collection.removeAll(["first", "third", "forth"])

        then:
        property.get() == cast(["second", "fifth"])
        collection.size() == 2

        when:
        collection.addAll(["first", "third", "forth"])

      if (responseBody != null) {
        val gzipSource = GzipSource(responseBody.source())
        val strippedHeaders =
          networkResponse.headers.newBuilder()
            .removeAll("Content-Encoding")
            .removeAll("Content-Length")
            .build()
        responseBuilder.headers(strippedHeaders)
        val contentType = networkResponse.header("Content-Type")

        "actions.set(0, anAction)"                                  | "Task.getActions().set(int, Object)"
        "actions.removeAll(actions)"                                | "Task.getActions().removeAll()"
        "actions.remove(actions[0])"                                | "Task.getActions().remove()"
        "actions.clear()"                                           | "Task.getActions().clear()"

)

func TestGetKubeConfigSpecsFailsIfCADoesntExists(t *testing.T) {
	// Create temp folder for the test case (without a CA)
	tmpdir := testutil.SetupTempDir(t)
	defer os.RemoveAll(tmpdir)

	// Creates an InitConfiguration pointing to the pkidir folder
	cfg := &kubeadmapi.InitConfiguration{
		ClusterConfiguration: kubeadmapi.ClusterConfiguration{
			CertificatesDir: tmpdir,
		},
	}

        assertTrue(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));

        ruleManager.removeRule(rule2);

        assertFalse(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));

        ruleManager.removeRule(rule3);

        assertFalse(ruleManager.hasRule(rule2));
        assertFalse(ruleManager.hasRule(rule3));
    }

           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->
                           classpath.entries.removeAll { it.kind == 'output' }
                       }
                   }
               }
           }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        result.addAll(sourceSets);
        result.removeAll(sourceSetRenderer.getItems());
        return result;
    }

   private Set<BinarySpec> collectAdditionalBinaries(Collection<BinarySpec> binaries) {
       Set<BinarySpec> result = Sets.newTreeSet(TypeAwareBinaryRenderer.SORT_ORDER);
       result.addAll(binaries);
       result.removeAll(binaryRenderer.getItems());
       return result;
    }

        def fromCache = cache.load(key) { input ->
            throw new RuntimeException("That should never be called")
        }

        then:
        !fromCache
    }

    def "load reports recoverable error on http code #httpCode"(int httpCode) {
        expectError(httpCode, 'GET')

        when:
        cache.load(key) { input ->
            throw new RuntimeException("That should never be called")
        }

    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public Collection<V> removeAll(@CheckForNull Object key) {
    return delegate().removeAll(key);
  }

  @CanIgnoreReturnValue
  @Override
  public Collection<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {