t.Fatalf("envelopeTransformer transformed data incorrectly. Expected: %v, got %v", originalText, untransformedData)
				}
			}
		})
	}
}

// Makes Envelope transformer hit cache limit, throws error if it misbehaves.
func TestEnvelopeCacheLimit(t *testing.T) {
	cbcTransformer := func(block cipher.Block) (value.Transformer, error) {
		return aestransformer.NewCBCTransformer(block), nil
	}

        then:
        1 * factory.create() >> "transformed"
        result == "transformed"
    }

    def constants() {
        def foo = "foo"
        expect:
        constant(foo).transform(null).is(foo)
    }

class StringToEnumTransformerTest extends Specification {

    def transformer = new StringToEnumTransformer()

    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

     * Base class implementation applies the {@link ClassTransform} to the code.
     *
     * @param builder the builder for the transformed output
     * @param classEntry the entry to process
     * @throws IOException if reading or writing entry fails
     */

        encoder.writeSmallInt(transformed.getConfigurationNames().size());
        for (String configurationName: transformed.getConfigurationNames()) {
            ConfigurationMetadata configuration = transformed.getConfiguration(configurationName);

     * @param <O> The type of the transformed object
     * @param <I> The type of the object to be transformed
     * @return A transformer that simply type casts the input to the given output type.
     */
    public static <O, I> Transformer<O, I> cast(Class<O> outputType) {
        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> Transformer<T, T> noOpTransformer() {

                    to.attribute(artifactType, 'size')
                }
            }

            def transformed = configurations.compile.incoming.artifactView { attributes.attribute(artifactType, 'size') }.files

            task resolve(type: ShowFilesTask) {
                inFiles.from(transformed)
            }

            abstract class MakeSize implements TransformAction<None> {
                @InputArtifact

        this.modelRegistry = modelRegistry;
        this.ruleFactory = new ClosureBackedRuleFactory(relativeFilePathResolver);
    }

    /**
     * Invoked by transformed DSL configuration rules
     */
    public void configure(String modelPathString, Closure<?> closure) {
        ModelPath modelPath = ModelPath.path(modelPathString);

                        println "Transformed artifact: \${it.file.name} (\${it.id.componentId}), location: \${it.file.absolutePath}"
                    }
                }
            }
        """
        expect:
        execute(buildA, "resolve")
        assertTaskExecuted(":buildB", ":jar")
        assertTaskExecuted(":buildC", ":jar")

        outputContains("Transformed artifact: buildB-1.0.jar.xform (project :buildB)")

                return dependency.withRequested(newSelector);
        });
        return this.withDependencies(transformed);
    }

    private IvyModuleResolveMetadata withDependencies(List<IvyDependencyDescriptor> transformed) {
        return new DefaultIvyModuleResolveMetadata(this, transformed);
    }

    @Override
    public ImmutableList<IvyDependencyDescriptor> getDependencies() {