* limitations under the License.
 */

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

import org.gradle.api.internal.artifacts.transform.ComponentVariantIdentifier
import org.gradle.api.internal.artifacts.transform.TransformStepNode
import org.gradle.api.internal.artifacts.transform.TransformedProjectArtifactSet
import org.gradle.internal.extensions.stdlib.uncheckedCast

    private final FileSystemAccess fileSystemAccess;
    private final ImmutableWorkspaceProvider workspaceProvider;

    public NonNormalizedIdentityImmutableTransformExecution(
        Transform transform,
        File inputArtifact,
        TransformDependencies dependencies,
        TransformStepSubject subject,

        TransformExecutionListener transformExecutionListener,

            }

            abstract class TestUnzipTransform extends ${UnzipTransform.class.name} {
                @Override
                public void transform(TransformOutputs outputs) {
                    println "Executing unzip transform..."
                    super.transform(outputs)
                }
            }

            dependencies {
                registerTransform(TestUnzipTransform) {

        return new EscapeUserArgs().transform(original);
    }

    public static List<String> escapeUserArgs(List<String> original) {
        return new EscapeUserArgs().transform(original);
    }

    @Override
    public String transform(String original) {
        return original.replace("\\", "\\\\").replace("\"", "\\\"");
    }

    public List<String> transform(List<String> args) {

 */

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

import com.google.common.collect.ImmutableList
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedArtifactSet
import org.gradle.api.internal.artifacts.transform.AbstractTransformedArtifactSet
import org.gradle.api.internal.artifacts.transform.TransformedExternalArtifactSet
import org.gradle.internal.serialize.graph.Codec

package org.gradle.sample.transform.javamodules;

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;
import org.gradle.api.tasks.Input;
import org.objectweb.asm.ClassWriter;

 * 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.attributes.AttributeContainer;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;
import org.gradle.internal.id.ConfigurationCacheableIdFactory;

     * Possible results from a resource lock state transform.
     */
    enum Disposition { FAILED, FINISHED, RETRY }

    /**
     * Registers a resource lock to be rolled back if the transform associated with this resource lock state
     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**
     * Registers a resource lock that has been unlocked during the transform so that the coordination service can

    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",