core.setOutput('sys-prop-args', '')
            }
      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v5
        with:
          cache-read-only: ${{ github.ref != 'refs/heads/master' }}
      - run: ./gradlew compileAll -DdisableLocalCache=true ${{ steps.determine-sys-prop-args.outputs.sys-prop-args }}
      - uses: actions/upload-artifact@v6
        if: always()
        with:
          name: build-receipt.properties

        // Test successful initialization with custom properties
        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.nativeOs", "CustomOS");
        props.setProperty("jcifs.smb.client.nativeLanMan", "CustomLanman");
        assertDoesNotThrow(() -> SingletonContext.init(props));
        CIFSContext context = SingletonContext.getInstance();
        assertNotNull(context);

            }

            props.put(propName, propertyDoc);
        }

        for (PropertyDoc propertyDoc : props.values()) {
            classDoc.addClassProperty(propertyDoc);
        }
    }

        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useMultiChannel", "true");
        props.setProperty("jcifs.smb.client.maxChannels", "4");
        props.setProperty("jcifs.smb.client.loadBalancingStrategy", "adaptive");
        props.setProperty("jcifs.smb.client.channelHealthCheckInterval", "5");

        multiConfig = new PropertyConfiguration(props);

        updateProperties(fetchedVersions)
    }

    private
    fun getPluginIds(): List<String> {
        val props = Properties()
        propertiesFile.get().asFile.reader().use { input ->
            props.load(input)
        }
        return props.keys.map { it as String }.sorted()
    }

    private
    fun fetchLatestVersions(pluginIds: List<String>): List<TestedVersion> =
        pluginIds

## Acerca de las integraciones de terceros { #about-third-party-integrations }

En este ejemplo estamos usando el flujo de OAuth2 "password".

Esto es apropiado cuando estamos iniciando sesión en nuestra propia aplicación, probablemente con nuestro propio frontend.

Porque podemos confiar en ella para recibir el `username` y `password`, ya que la controlamos.

     *
     * This method can only be called once.
     *
     * @param props the properties to use for initialization
     * @throws CIFSException if the singleton context is already initialized or there is an error during initialization
     */
    public static synchronized final void init(final Properties props) throws CIFSException {
        if (INSTANCE != null) {

    final ClassMetaData classMetaData = Mock()
    final PropertyMetaData propertyMetaData = new PropertyMetaData('prop', classMetaData)

    def formatsSignature() {
        def type = new TypeMetaData('org.gradle.SomeClass')
        propertyMetaData.type = type

        expect:
        propertyMetaData.signature == 'org.gradle.SomeClass prop'
    }

    def usesGetterToLocateOverriddenProperty() {
        MethodMetaData getter = Mock()

        Properties props = cliRequest.getUserProperties();
        if (cliRequest.getRootDirectory() != null) {
            props = new Properties();
            props.putAll(cliRequest.getUserProperties());
            props.put("session.rootDirectory", cliRequest.getRootDirectory().toString());
        }
        settingsRequest.setUserProperties(props);

        this(container, null);
    }

    /**
     * the properties passed to the profile manager are the props that
     * are passed to maven, possibly containing profile activator properties
     *
     */
    public DefaultProfileManager(PlexusContainer container, Properties props) {
        try {
            this.profileSelector = container.lookup(ProfileSelector.class);