artifactTypes.getByName("jar") {
        attributes.attribute(filteredAttribute, Filtering.ALL)
    }

    // Filters out classes that are not exposed by our API.
    // TODO Use actual filtering not copying
    registerTransform(CopyPublicApiClassesTransform::class.java) {
        from.attribute(filteredAttribute, Filtering.ALL)

                }
            }

            dependencies {
                registerTransform(UnzipTransform) {
                    from.attribute(augmented, false).attribute(artifactType, "zip")
                    to.attribute(augmented, false).attribute(artifactType, "directory")
                }
                registerTransform(AugmentTransform) {

                dependencies {
                    compile project(':lib')
                    registerTransform(FileDoubler) {
                        from.attribute(artifactType, "jar")
                        to.attribute(artifactType, "double")
                    }
                    registerTransform(FileSizer) {
                        from.attribute(artifactType, "double")

                }
            }

            dependencies {
                registerTransform(UnzipTransform) {
                    from.attribute(augmented, false).attribute(artifactType, "zip")
                    to.attribute(augmented, false).attribute(artifactType, "directory")
                }
                registerTransform(AugmentTransform) {

        return artifactTypeContainer.getDefaultArtifactAttributes();
    }

    @Override
    public <T extends TransformParameters> void registerTransform(Class<? extends TransformAction<T>> actionType, Action<? super TransformSpec<T>> registrationAction) {
        transforms.registerTransform(actionType, registrationAction);
    }

    @Override
    public Dependency platform(Object notation) {

                def instrumented = Attribute.of('${INSTRUMENTED_ATTRIBUTE.name}', String.class)
                dependencies {
                    classpath "com.test:lib:1.0"
                    registerTransform(MakeColor) {
                        from.attribute(artifactType, 'jar').attribute(instrumented, '${NOT_INSTRUMENTED.value}')

        withIdentityTransform()
        buildFile '''
            apply plugin: 'base'
            configurations {
                implementation
            }
            dependencies {
                registerTransform(IdentityTransform) {
                    from.attribute(artifactType, 'zip')
                    to.attribute(artifactType, 'jar')
                }
                implementation(project(':p1'))

                }
            }

            allprojects {
                dependencies {
                   registerTransform(Multiplier) {
                        from.attribute(color, 'blue')
                        to.attribute(color, 'red')
                    }
                    registerTransform(MakeGreen) {
                        from.attribute(color, 'red')
                        to.attribute(color, 'green')

            dependencies {
                artifactTypes {
                    green {
                        attributes.attribute(color, 'green')
                    }
                }
                registerTransform(MakeRed) {
                    from.attribute(color, 'green')
                    to.attribute(color, 'red')
                }
            }

            configurations {
                transformed

        throw UnsupportedOperationException("Should not be called")
    }
}


private
object EmptyVariantTransformRegistry : VariantTransformRegistry {
    override fun <T : TransformParameters?> registerTransform(actionType: Class<out TransformAction<T>>, registrationAction: Action<in org.gradle.api.artifacts.transform.TransformSpec<T>>) {
        throw UnsupportedOperationException("Should not be called")
    }