this.classifier = classifier;
        this.buildDependencies = taskDependencyFactory.visitingDependencies(context -> context.add(getGenerator()));
    }

    @Override
    public File getFile() {
        return getGenerator().getOutputs().getFiles().getSingleFile();
    }

    private Task getGenerator() {
        return generator.get();
    }

    @Override
    protected String getDefaultExtension() {

        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public String getGenerator() {
        checkSpecifiedProperty("generator");
        return convertEmptyToNull(generator);
    }

    public void setGenerator(String value) {
        registerModifiedProperty("generator");
        this.generator = value;
    }

    public String getPath() {

                (et, vl) -> ((ThumbnailQueue) et).setCreatedTime(DfTypeUtil.toLong(vl)), "createdTime");
        setupEpg(_epgMap, et -> ((ThumbnailQueue) et).getGenerator(),
                (et, vl) -> ((ThumbnailQueue) et).setGenerator(DfTypeUtil.toString(vl)), "generator");
        setupEpg(_epgMap, et -> ((ThumbnailQueue) et).getPath(), (et, vl) -> ((ThumbnailQueue) et).setPath(DfTypeUtil.toString(vl)),
                "path");

     */
    public void generate() {
        Generator generator = getGenerator();
        if (generator == null) {
            return;
        }
        generator.generate();
    }

    @Nullable
    Generator getGenerator() {
        File toSign = getToSign();
        if (toSign == null) {
            if (signatureSpec.isRequired()) {

abstract class AbstractClassGeneratorSpec extends Specification {
    @ClassRule
    @Shared
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    abstract ClassGenerator getGenerator()

    protected <T> T createForSerialization(Class<T> clazz) {
        def nested = Stub(InstanceGenerator)
        _ * nested.newInstanceWithDisplayName(_, _, _) >> { type, name, params -> create(type) }

        def text = new ByteArrayOutputStream()
        getGenerator(options).write(result, text)
        return text.toString("UTF-8").replace(SystemProperties.instance.lineSeparator, "\n")
    }

    private JUnitXmlResultWriter getGenerator(JUnitXmlResultOptions options) {
        return new JUnitXmlResultWriter("localhost", provider, options)
    }

import spock.lang.Specification

class JUnitXmlResultWriterMergeRerunSpec extends Specification {

    def provider = new BuildableTestResultsProvider()
    def outputPerTestCase = true

    protected JUnitXmlResultWriter getGenerator() {
        new JUnitXmlResultWriter("localhost", provider, new JUnitXmlResultOptions(outputPerTestCase, true, true, true))
    }

    def "merges for simple case - output per testcase"() {
        when:

        if (getSignatory() == null) {
            // The task will fail, so we don't need any state.
            return Collections.emptyList();
        }
        return signatureStream()
            .map(Signature::getGenerator)
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
    }

    private Stream<Signature> signatureStream() {
        return getSignatures().stream();
    }

    @Inject

        systemHelper.calibrateCpuLoad();

        if (logger.isDebugEnabled()) {
            logger.debug("Processing thumbnail: {}", entity);
        }
        final String generatorName = entity.getGenerator();
        try {
            final File outputFile = new File(baseDir, entity.getPath());
            final File noImageFile = new File(outputFile.getAbsolutePath() + NOIMAGE_FILE_SUFFIX);

		benchmarkScalarMult(b, nistec.NewP224Point().SetGenerator(), 28)
	})
	b.Run("P256", func(b *testing.B) {
		benchmarkScalarMult(b, nistec.NewP256Point().SetGenerator(), 32)
	})
	b.Run("P384", func(b *testing.B) {
		benchmarkScalarMult(b, nistec.NewP384Point().SetGenerator(), 48)
	})
	b.Run("P521", func(b *testing.B) {
		benchmarkScalarMult(b, nistec.NewP521Point().SetGenerator(), 66)
	})
}