}
            }
            transform.provider = new MappingProvider(String, Providers.of("value"), transform)
            return transform.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [ProviderConsumer.TO_STRING, ProviderConsumer.GET_PRODUCER, ProviderConsumer.CALCULATE_PRESENCE]
        }
    }

    CompiledLanguage language = CompiledLanguage.GROOVY

    private String goodAstTransformation() {
        """
            import org.codehaus.groovy.transform.*;
            import org.codehaus.groovy.ast.*;
            import org.codehaus.groovy.control.*;
            @GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION)

				},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			actual := StringMatcherWithPrefix(tc.v, tc.prefix)
			if !cmp.Equal(actual, tc.want, protocmp.Transform()) {
				t.Errorf("want %s but got %s", tc.want.String(), actual.String())
			}
		})
	}
}

func TestStringMatcherRegex(t *testing.T) {
	testCases := []testCase{
		{
			name: "wildcardAsRequired",

 * limitations under the License.
 */

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

import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.internal.DocumentationRegistry
import org.gradle.api.internal.artifacts.transform.DefaultTransform
import org.gradle.api.internal.artifacts.transform.TransformParameterScheme
import org.gradle.api.internal.file.FileCollectionFactory

        when:
        dsl {
            apply plugin: pluginClass
        }

        then:
        def transform = realize("languageTransforms").find { it.languageName == languageId }

        transform != null
        transform.sourceSetType == languageSourceSet
    }

    static enum TestEnum {
        ABC, DEF
    }

    def "can transform enums correctly - #desc"() {
        def typesArray = types.collect { new CachedClass(it, null) } as CachedClass[]
        def argsArray = args as Object[]

        expect:
        transformer.transform(typesArray, argsArray).toList() == transformed

        where:

    private InternalTransformer<Object, Object> objectTransformer = new InternalTransformer<Object, Object>() {
        @Override
        public Object transform(Object o) {
            try {
                return doResolveObject(o);
            } catch (IOException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    };

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

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

import org.gradle.api.artifacts.transform.CacheableTransform;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.internal.properties.annotations.AbstractTypeAnnotationHandler;
import org.gradle.internal.reflect.validation.TypeValidationContext;

import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.transform.ASTTransformation;
import org.codehaus.groovy.transform.GroovyASTTransformation;

import java.lang.reflect.Modifier;

@GroovyASTTransformation
public class MagicFieldTransform implements ASTTransformation {

 */

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

import com.google.common.collect.ImmutableList;
import org.gradle.api.Describable;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;

import java.io.File;

/**
 * Transform subject is either an initial artifact for the transform chain or a result of a previous transform step.