this.registrationFactory = registrationFactory;
        this.parametersInstantiationScheme = parametersInstantiationScheme;
    }

    @Override
    public <T extends TransformParameters> void registerTransform(Class<? extends TransformAction<T>> actionType, Action<? super TransformSpec<T>> registrationAction) {
        TypedRegistration<T> registration = null;
        try {

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

There are a few points to consider when using `registerTransform()`:

- The `from` and `to` attributes are required.

                }
            }

            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

     *     }
     * }
     *
     * // Then you can register the action like this:
     *
     * def artifactType = Attribute.of('artifactType', String)
     *
     * dependencies.registerTransform(MyTransform) {
     *     from.attribute(artifactType, "jar")
     *     to.attribute(artifactType, "java-classes-directory")
     *
     *     parameters {
     *         stringParameter.set("Some string")

        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")
    }

                        compile {
                            attributes.attribute usage, 'api'
                        }
                    }
                    dependencies {
                        registerTransform(SynchronizedTransform) {
                            from.attribute(artifactType, "jar")
                            to.attribute(artifactType, "size")
                        }
                    }

                // unique from each other
                registerTransform(BrokenTransform::class.java) {
                    from.attribute(color, "blue")
                    to.attribute(color, "red")
                    from.attribute(matter, "liquid")
                    to.attribute(matter, "solid")
                }
                registerTransform(BrokenTransform::class.java) {

                ext.inputFiles = configurations.toolsPath.incoming.artifactView {
                    attributes.attribute(attr, 'red')
                }.files
                dependencies {
                    registerTransform(MakeRed) {
                        from.attribute(color, 'blue')
                        to.attribute(color, 'red')
                    }
                }
            }

            project(':a') {