}
	}

	associationDB := association.DB.Session(&Session{}).Model(nil)
	if !association.DB.FullSaveAssociations {
		associationDB.Select(selectedSaveColumns)
	}
	if len(omitColumns) > 0 {
		associationDB.Omit(omitColumns...)
	}
	associationDB = associationDB.Session(&Session{})

	switch reflectValue.Kind() {
	case reflect.Slice, reflect.Array:

        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());

import jcifs.internal.smb1.AndXServerMessageBlock;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Session Setup AndX Response message.
 *
 * This response contains information about the established session,
 * including native OS, LAN manager, and primary domain information.
 */
public class SmbComSessionSetupAndXResponse extends AndXServerMessageBlock {

     */
    @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

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that annotated component should be instantiated before session execution starts
 * and discarded after session execution completes.
 * <p>
 * A {@code org.apache.maven.api.Session} object is available in the scope of this annotation.
 *
 * @since 4.0.0
 */
@Scope
@Documented
@Retention(RUNTIME)
@Target({TYPE, METHOD})

 * based on the current Maven session and environment.
 *
 * @since 4.0.0
 * @see RequestCache
 */
@Experimental
public interface RequestCacheFactory {

    /**
     * Creates a new RequestCache instance.
     * The created cache should be configured according to the current Maven session
     * and environment settings.
     *
     * @return A new RequestCache instance

        }

        return result;
    }

    @Override
    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        // noop
    }

    @Override
    public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
        LocalMetadataResult result = new LocalMetadataResult(request);

        String path;

        MavenSession session = legacySupport.getSession();

        PluginDescriptor pluginDescriptor;
        try {
            pluginDescriptor = pluginManager.getPluginDescriptor(
                    plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());

            pluginManager.setupPluginRealm(pluginDescriptor, session, null, null, null);

            SmbSession mockSession = mock(SmbSession.class);

            assertDoesNotThrow(() -> {
                try (SmbSession session = mockSession) {
                    // Resource usage simulation
                    session.getConfig();
                }
            }, "SmbSession should work with try-with-resources");

            verify(mockSession, times(1)).close();
        }

            builder.setAuthentication(session.getAuthenticationSelector().getAuthentication(remoteRepo));
            builder.setProxy(session.getProxySelector().getProxy(remoteRepo));
            remoteRepo = builder.build();
        }
        request.setRepository(remoteRepo);

        DeployResult result;
        try {
            result = repoSystem.deploy(session, request);
        } catch (DeploymentException e) {