}

    private void injectSession(MetadataResolutionRequest request) {
        RepositorySystemSession session = legacySupport.getRepositorySession();

        if (session != null) {
            request.setOffline(session.isOffline());
            request.setForceUpdate(RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals(session.getUpdatePolicy()));
        }
    }

    @Override
    public ResolutionGroup retrieve(

 */
package jcifs.internal.smb2.session;

import jcifs.CIFSContext;
import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Session Setup request message. This command is used to establish a security session
 * and authenticate a user to the server.
 *

    /** Called name not present */
    public static final int CALLED_NOT_PRESENT = 0x82;
    /** Insufficient resources to establish session */
    public static final int NO_RESOURCES = 0x83;
    /** Unspecified session service error */
    public static final int UNSPECIFIED = 0x8F;

    /** The NetBIOS error class */
    public int errorClass;
    /** The NetBIOS error code */

                .session(requireNonNull(session, "session cannot be null"))
                .groupId(groupId)
                .artifactId(artifactId)
                .version(version)
                .extension(extension)
                .build();
    }

    static ArtifactFactoryRequest build(
            Session session,
            String groupId,
            String artifactId,
            String version,

     * @see #build(ToolchainsBuilderRequest)
     */
    @Nonnull
    default ToolchainsBuilderResult build(
            @Nonnull Session session,
            @Nonnull Source installationToolchainsFile,
            @Nonnull Source userToolchainsSource) {
        return build(ToolchainsBuilderRequest.build(session, installationToolchainsFile, userToolchainsSource));
    }

    static DependencyCoordinatesFactoryRequest build(
            @Nonnull Session session,
            String groupId,
            String artifactId,
            String version,
            String classifier,
            String extension,
            String type) {
        return DependencyCoordinatesFactoryRequest.builder()
                .session(requireNonNull(session, "session cannot be null"))
                .groupId(groupId)

| *Required*    | *No*                                               |

### Policy

     */
    @Nonnull
    default List<Toolchain> getToolchains(@Nonnull Session session, @Nonnull String type)
            throws ToolchainManagerException {
        return getToolchains(session, type, null);
    }

    /**
     * Retrieves the currently active toolchain from the build context.
     *
     * @param session The Maven session context
     * @param type The type of toolchain to retrieve

        eps.setProperty("jre.home", new File(pom.getParentFile(), "jdk/jre").getPath());

        MavenSession session = createMavenSession(pom, eps);
        MavenProject project = session.getCurrentProject();

        project.setArtifacts(resolver.resolve(project, Collections.singleton(Artifact.SCOPE_COMPILE), session));

        List<String> elements = project.getCompileClasspathElements();
        assertEquals(2, elements.size());

  }
  return ret;
}

TF_Tensor* TF_DequeueNamedTensor(TF_Session* session, int tensor_id,
                                 TF_Status* status) {
  assert(session);
  {
    tensorflow::mutex_lock c(session->graph->mu);
    VLOG(1) << "Dequeuing named tensor with id " << tensor_id
            << ", with input graph: "
            << session->graph->graph.ToGraphDefDebug().DebugString();
  }