* limitations under the License.
 */

package org.gradle.api.internal.initialization.transform.utils;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.gradle.api.internal.initialization.transform.InstrumentationArtifactMetadata;
import org.gradle.api.internal.initialization.transform.InstrumentationDependencyAnalysis;

import java.io.File;
import java.util.Map;
import java.util.Set;

 * limitations under the License.
 */

package org.gradle.integtests.resolve.transform

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest

class CrashingBuildsArtifactTransformIntegrationTest extends AbstractDependencyResolutionTest {
    def "cleans up cached output after build process crashes during transform"() {
        given:
        buildFile << """

enum Color { Red, Green, Blue }

         * <p>
         * This is using the visitor from {@link SnapshotTaskInputsBuildOperationType} since there is no difference
         * between tasks and transforms in this regard. Later we can unify the transform and the task build operation type.
         */
        void visitInputFileProperties(FilePropertyVisitor visitor);

        /**
         * The names of the output properties.
         * <p>

 * limitations under the License.
 */

package org.gradle.internal.serialize.codecs.dm.transform

import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.internal.artifacts.transform.DefaultTransform
import org.gradle.api.internal.artifacts.transform.TransformActionScheme
import org.gradle.api.internal.attributes.ImmutableAttributes
import org.gradle.api.internal.file.FileLookup

                    throw new InvalidUserDataException("Transform output file " + output.getPath() + " must be a file, but is not.");
                }
                if (outputDirectories.contains(output) && !output.isDirectory()) {
                    throw new InvalidUserDataException("Transform output directory " + output.getPath() + " must be a directory, but is not.");
                }
            }

        System.out.println("> Cleaning '<gradle-home>/caches/transforms-*/' and '<gradle-home>/caches/<gradle-version>/transforms/*' caches in " + gradleUserHome)
        File caches = new File(gradleUserHome, "caches")

        // <gradle-home>/caches/transforms-*
        List<File> oldCaches = caches.listFiles().findAll {
            it.isDirectory() && it.name.startsWith("transforms-")
        }

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

package org.gradle.api.internal.artifacts.transform;

/**
 * Marker interface to signal a dependency on an artifact transform.
 */
public interface TransformNodeDependency {

public class ExceptionReplacingObjectOutputStream extends ObjectOutputStream {
    private InternalTransformer<Object, Object> objectTransformer = new InternalTransformer<Object, Object>() {
        @Override
        public Object transform(Object obj) {
            try {
                return doReplaceObject(obj);
            } catch (IOException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    };

    public ChainingTransformer(Class<T> type) {
        this.type = type;
    }

    @Override
    public T transform(T original) {
        T value = original;
        for (Transformer<T, T> transformer : transformers) {
            value = type.cast(transformer.transform(value));
        }
        return value;
    }

    public void add(Transformer<T, T> transformer) {

        final greeter = new CppGreeterFunction().asLib()
        final alternateGreeter = new CppAlternateHeaderGreeterFunction().asLib()

        final String moduleName = "cppGreeter"
        final List<IncrementalElement.Transform> incrementalChanges = [modify(greeter, alternateGreeter)]
    }

    class IncrementalSwiftAppWithCppDep extends IncrementalSwiftApp {
        final SwiftMainWithCppDep main
        final SwiftMainWithCppDep alternateMain