}

        return pomArtifact;
    }

    /**
     * Creates POM artifact out of passed in artifact by dropping classifier (if exists) and rewriting extension to
     * "pom". Unconditionally, unlike {@link #toPomArtifact(Artifact)} that does this only for artifacts without
     * classifiers.
     *
     * @since 4.0.0
     */
    public static Artifact toPomArtifactUnconditionally(Artifact artifact) {

        getContainsEntryWithIncomparableValueMethod());
  }

  @Override
  protected Collection<Method> suppressForConcurrentHashMap() {
    /*
     * The entrySet() of ConcurrentHashMap, unlike that of other Map
     * implementations, supports add() under JDK8. This seems problematic, but I
     * didn't see that discussed in the review, which included many other
     * changes: http://goo.gl/okTTdr
     *

namespace tensorflow {
namespace experimental {
namespace cc {

// An opaque representation of a tensor computed/managed by the Tensorflow
// runtime (tensorflow:cc::Runtime). Unlike a tensor, a Tensorhandle may refer
// to tensors placed in memory of different devices or remote address spaces.
// Note that tensorflow::cc::Runtime MUST outlive all TensorHandles created
// from it.
class TensorHandle {

            }
            zipTree(file("hello.zip")).files
        """

        expect:
        succeeds "clean"
    }

    def "clean after unzipping during configuration, then unzip again in a different task"() {
        buildFile << """
            plugins {
                id 'lifecycle-base'
            }
            System.out.println("Files in the archive: " + zipTree(file("hello.zip")).files)

typedef llvm::function_ref<llvm::SmallVector<Operation *, 4> const &(
    Operation *, bool incoming)>
    ExtraDependenciesFunction;

// Convenience function if there are no extra dependencies to declare.
// (Unlike nullptr, this also works inside the ternary operator)
extern ExtraDependenciesFunction no_extra_dependencies;

// Sort a block topologically, so that for all ops, all operands are

			break;
		}
		case 3: {
			if (verbose) {
				printf("attempting SIGPIPE\n");
			}

			int fd[2];
			if (pipe(fd) != 0) {
				printf("pipe(2) failed\n");
				return 0;
			}
			// Close the reading end.
			close(fd[0]);
			// Expect that write(2) fails (EPIPE)
			if (write(fd[1], "some data", 9) != -1) {
				printf("write(2) unexpectedly succeeded\n");
				return 0;
			}

import org.gradle.api.NonNullApi;
import org.gradle.api.provider.Provider;
import org.gradle.plugin.use.PluginDependency;

import java.util.List;
import java.util.Optional;

/**
 * Provides access to a version catalog. Unlike generated extension
 * classes for catalogs, there is no guarantee that the requested
 * aliases exist, so you must check existence on the returned optional
 * values.
 *
 * @since 7.0
 */
@NonNullApi

import java.util.concurrent.TimeoutException;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A {@link FutureTask} that also implements the {@link ListenableFuture} interface. Unlike {@code
 * FutureTask}, {@code ListenableFutureTask} does not provide an overrideable {@link
 * FutureTask#done() done()} method. For similar functionality, call {@link #addListener}.
 *

// collected, and thereby "unallocating" the reserved resources.
func (mp *MultipointExample) Unreserve(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) {
	// Unlike Reserve, the Unreserve method may be called concurrently since
	// there is no guarantee that there will only one unreserve operation at any
	// given point in time (for example, during the binding cycle).
	mp.mu.Lock()

# This corresponds to boringssl.googlesource.com/boringssl tag fips-20210429.
ENV ClangV=12
RUN apt-get update && \
        apt-get install --no-install-recommends -y cmake xz-utils wget unzip ca-certificates clang-$ClangV python

# Download, validate, unpack, build, and install Ninja.
ENV NinjaV=1.10.2
ENV NinjaH=ce35865411f0490368a8fc383f29071de6690cbadc27704734978221f25e2bed
RUN \