sys, ok := fi.Sys().(*syscall.Stat_t)
	if !ok {
		return nil
	}
	h.Uid = int(sys.Uid)
	h.Gid = int(sys.Gid)
	if doNameLookups {
		// Best effort at populating Uname and Gname.
		// The os/user functions may fail for any number of reasons
		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)

        e.message.startsWith("There was a failure while populating the build operation queue:")
        e.message.contains("operations failed")
        e.message.contains("failed operation 1")
        e.message.contains("failed operation 2")
        e.causes.size() == 2
        e.causes.any { it instanceof BuildOperationQueueFailure && it.message.startsWith("There was a failure while populating the build operation queue:") }

import org.gradle.internal.build.BuildState;
import org.gradle.internal.build.ExecutionResult;

import java.io.Closeable;

interface BuildControllers extends Closeable {
    /**
     * Finish populating work graphs, once all entry point tasks have been scheduled.
     */
    void populateWorkGraphs();

    /**

        verifier.verify(logger, calls(1)).debug("  Excluded: {}", "group1:artifact2:ext:classifier1:null");
        verifier.verify(logger, calls(1))
                .debug("Populating class realm {}", "project>modelGroup1:modelArtifact1:modelVersion1");
        verifier.verify(logger, calls(1)).debug("  Included: {}", "group1:artifact1:ext:classifier1:null");
    }

    @Test

  }

  return compile_options;
}

// Gets `variables` from `ctx`, locks them and builds XlaCompiler::Arguments
// using them. Stores the arguments in `args`. `variables` and `args` passed in
// will be cleared before populating them.
Status GetAndLockVariablesAndBuildXlaCompilerArguments(
    const OpKernelContext& ctx, const std::vector<const Tensor*>& inputs,
    const std::vector<int>& constant_indices,
    const std::vector<int>& variable_indices,

 * under the License.
 */
package org.apache.maven.execution;

import org.apache.maven.settings.Settings;
import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Assists in populating an execution request for invocation of Maven.
 *
 */
public interface MavenExecutionRequestPopulator {
    /**

   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a

   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a

                }
            }
        """

        when:
        fails("causeErrors")

        then:
        failure.assertHasCause("There was a failure while populating the build operation queue:")
        failure.assertThatCause(Matchers.containsText("Multiple build operations failed"));
    }

    // This is the current behavior:

   * <p>An example use case for this method is in implementing an {@code Iterator<T>} whose {@code
   * next} field is lazily initialized. The type of that field would be {@code @Nullable T}, and the
   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a