import gradlebuild.testcleanup.extension.TestFilesCleanupProjectState

/**
 * When run from a Continuous Integration environment, we only want to archive a subset of reports, mostly for
 * failing tasks only, to not use up unnecessary disk space on Team City. This also improves the performance of
 * artifact publishing by reducing the artifacts and packaging reports that consist of multiple files.
 *

package org.gradle.internal.execution.history.changes;

import com.google.common.collect.ImmutableList;

import java.util.List;

/**
 * Provides an efficient summary of the changes, without doing too much unnecessary work.
 * - Will only emit changes of a single type (from a single delegate change set)
 */
public class SummarizingChangeContainer implements ChangeContainer {
    private final List<ChangeContainer> sources;

import org.gradle.internal.serialize.graph.WriteContext


/**
 * This class exists because PublishArtifactLocalArtifactMetadata is used as its own id, and so when serialized as an id causes
 * a lot of unnecessary and unserializable state to be dragged in.
 *
 * A better change would be to split an immutable id type out of PublishArtifactLocalArtifactMetadata (or reuse one of the existing

        // If SanityCheck fails, Gradleception will definitely fail because the last build step is also sanityCheck
        dependsOn(RelativeId(SanityCheck.buildTypeId(model)))
    }

    /*
     To avoid unnecessary rerun, what we do here is a bit complicated:

     1. Build a Gradle distribution with a fixed timestamp and hash it, but never use this distribution.

    /**
     * Stops recording [ClassLoaderScopeSpec]s and releases any recorded state.
     */
    fun dispose() {
        synchronized(lock) {
            // TODO:configuration-cache find a way to make `dispose` unnecessary;
            //  maybe by extracting an `ConfigurationCacheBuildDefinition` service
            //  from DefaultConfigurationCacheHost so a decision based on the configured

        synchronized (delegate) {
            delegate.replaceAll((k, v) -> {
                Object newValue = function.apply(k, v);
                // It is a bit of optimization to avoid storing unnecessary stores when the value doesn't change.
                // Strings and primitive wrappers are tested with "equals", user types are tested for reference

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

/**
 * Context necessary for steps that change the outputs.
 *
 * This context doesn't add any new information, it encodes a requirement
 * in the type system that a step can change the outputs.
 */

   This build uses PGP verification and SHA256 checksum verification for unsigned artifacts:

   ./gradlew -i -write-verification-metadata sha256,pgp -export-keys resolveAllDependencies

   Then check the diff, remove the unnecessary entries (for old dependencies) and make sure
   the new ones are correct. If any ignored keys are added, attempt to download them from a keyserver
   and follow the steps in documentation to add them to the keyring if found.

        return doRegisterTestProject(testProject, type, configurationAction) {
            // AndroidStudio jvmArgs could be set per project, but at the moment that is not necessary
            jvmArgumentProviders.add(androidProjectJvmArguments)
            environment("JAVA_HOME", LazyEnvironmentVariable { javaLauncher.get().metadata.installationPath.asFile.absolutePath })
        }
    }

 */
public interface MethodArgumentsTransformer {

    /**
     * Transforms an argument list to call a method with.
     *
     * May return {@code args} if no transform is necessary.
     */
    Object[] transform(CachedClass[] types, Object[] args);

    /*
     * Returns Whether the transformer can transform
     * these arguments at all.
     */
    boolean canTransform(Object[] args);