def second = container.maybeCreate("fred")

        then:
        container.size() == 1
        container.findByName("fred") == fred
        first == second
    }

    def "throws meaningful exception if it doesn't support creating domain objects without specifying a type"() {
        container = createContainer()

        when:
        container.create("fred")

        then:

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Simple {@link ThreadFactory} implementation that ensures the corresponding threads have a meaningful name.
 */
public class BuildThreadFactory implements ThreadFactory {
    private final AtomicInteger id = new AtomicInteger();

    private static final String PREFIX = "BuilderThread";

    @Override

   * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that
   * a failure that occurs when closing the stream indicates a meaningful problem such as a failure
   * to flush all bytes to the underlying resource.
   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing
   * @since 17.0

 */

package org.gradle.internal.concurrent;

import javax.annotation.Nullable;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Provides meaningful names to threads created in a thread pool.
 */
public class ThreadFactoryImpl implements ThreadFactory {
    private final AtomicLong counter = new AtomicLong();
    private final String displayName;
    @Nullable

// concurrent getaddrinfo calls to less than the permitted number of
// file descriptors makes that error less likely. We don't bother to
// apply the same limit to DNS lookups run directly from Go, because
// there we will return a meaningful "too many open files" error.
func concurrentThreadsLimit() int {
	var rlim syscall.Rlimit
	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim); err != nil {
		return 500
	}
	r := rlim.Cur
	if r > 500 {

   * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that
   * a failure that occurs when closing the stream indicates a meaningful problem such as a failure
   * to flush all bytes to the underlying resource.
   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing
   * @since 17.0

 */
public interface BuildResumptionDataRepository {
    /**
     * Persists any data needed to resume the build at a later point in time, using a new Maven invocation. This method
     * may also decide it is not needed or meaningful to persist such data, and return <code>false</code> to indicate
     * so.
     *
     * @param rootProject The root project that is being built.
     * @param buildResumptionData Information needed to resume the build.

    @Requires([
        UnitTestPreconditions.HasXCode,
        UnitTestPreconditions.NotMacOsM1
    ]) // TODO KM: Not sure why error message is different on M1
    @ToBeFixedForConfigurationCache
    def "returns meaningful errors from xcode when component product is unbuildable due to architecture"() {
        useXcodebuildTool()

        given:
        makeSingleProject()

       require a JIRA issue. Your pull request should address just this issue, without
       pulling in other changes.
 - [ ] Each commit in the pull request should have a meaningful subject line and body.
 - [ ] Format the pull request title like `[MNG-XXX] SUMMARY`,
       where you replace `MNG-XXX` and `SUMMARY` with the appropriate JIRA issue.

        then:
        isReported * mockLogger.warn(_ as String, location.displayName)

        where:
        isValid << [false, true]
        isReported << [1, 0]
    }

    def 'reporter logs meaningful message'() {
        given:
        def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("testHome"), "test")