(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()) {

        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);

func NewP384Point() *P384Point {
	return &P384Point{
		x: new(fiat.P384Element),
		y: new(fiat.P384Element).One(),
		z: new(fiat.P384Element),
	}
}

// SetGenerator sets p to the canonical generator and returns p.
func (p *P384Point) SetGenerator() *P384Point {

func NewP256Point() *P256Point {
	return &P256Point{
		x: new(fiat.P256Element),
		y: new(fiat.P256Element).One(),
		z: new(fiat.P256Element),
	}
}

// SetGenerator sets p to the canonical generator and returns p.
func (p *P256Point) SetGenerator() *P256Point {

func NewP224Point() *P224Point {
	return &P224Point{
		x: new(fiat.P224Element),
		y: new(fiat.P224Element).One(),
		z: new(fiat.P224Element),
	}
}

// SetGenerator sets p to the canonical generator and returns p.
func (p *P224Point) SetGenerator() *P224Point {

func NewP521Point() *P521Point {
	return &P521Point{
		x: new(fiat.P521Element),
		y: new(fiat.P521Element).One(),
		z: new(fiat.P521Element),
	}
}

// SetGenerator sets p to the canonical generator and returns p.
func (p *P521Point) SetGenerator() *P521Point {