*/

package org.gradle.api.internal.tasks.compile;

import org.gradle.api.Transformer;
import org.gradle.api.tasks.compile.BaseForkOptions;
import org.gradle.process.JavaForkOptions;
import org.gradle.process.internal.JavaForkOptionsFactory;

public class BaseForkOptionsConverter implements Transformer<JavaForkOptions, BaseForkOptions> {
    private final JavaForkOptionsFactory forkOptionsFactory;

    }

    /**
     * Get the total artifact transform time.
     */
    public long getElapsedArtifactTransformTime() {
        long result = 0;
        for (FragmentedOperation transform : transforms.values()) {
            result += transform.getElapsedTime();
        }
        return result;
    }

    /**

 * limitations under the License.
 */

package gradlebuild.packaging.transforms

import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs
import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.file.FileSystemLocation
import org.gradle.api.provider.Provider

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        InputStream transformed = filterChain.transform(new ByteArrayInputStream(input.getBytes(charset.name())));
        // We read byte-by-byte to trigger edge cases in the downstream implementations.
        int read;
        while ((read = transformed.read()) != -1) {
            baos.write(read);
        }

        this.root = root;
        this.chain = chain;
    }

    /**
     * @return The transformed variant which results from applying the transform chain to the root variant.
     */
    public VariantDefinition getTransformedVariantDefinition() {
        return chain;
    }

    /**
     * @return The transform chain to apply to the root producer variant.
     */
    public TransformChain getTransformChain() {

    /**
     * Copies this state, but with the new component ID and the artifacts transformed by the given transformer.
     */
    LocalComponentGraphResolveState copy(ComponentIdentifier newComponentId, Transformer<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> transformer);

    /**
     * We currently allow a configuration that has been partially observed for resolution to be modified

        responseData.setResponseBody(data);
        final ResultData resultData = binaryTransformer.transform(responseData);
        assertEquals("xyz", new String(resultData.getData()));
    }

    public void test_transform_null() {
        try {
            binaryTransformer.transform(null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }
    }

    // This tests current behaviour, not desired behaviour
    @UnsupportedWithConfigurationCache(because = "Task does not declare that it uses the transform outputs")
    def "can consume transform outputs produced by another project without declaring this access"() {
        createDirs("a", "b", "sneaky")
        settingsFile << """
            include 'a', 'b', 'sneaky'
        """

                })
            }
        }

        def transformer = new CompileOperation<String>() {
            @Override
            String getId() {
                return "id"
            }

            @Override
            String getStage() {
                return "STAGE"
            }

            @Override
            Transformer getTransformer() {
                return visitor
            }

 * limitations under the License.
 */


package gradlebuild.binarycompatibility.transforms

import groovy.transform.CompileStatic
import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs
import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.file.FileSystemLocation