Stop() Result
}

// NewGenerator returns a new Generator with the given configuration.
func NewGenerator(t test.Failer, cfg Config) Generator {
	fillInDefaults(&cfg)
	return &generator{
		Config:  cfg,
		t:       t,
		stop:    make(chan struct{}),
		stopped: make(chan struct{}),
	}
}

var _ Generator = &generator{}

type generator struct {
	Config
	t       test.Failer
	result  Result

 * limitations under the License.
 */
package org.gradle.plugins.ide.internal.generator.generator;

import java.io.File;

/**
 * Responsible for reading, configuring and writing a config object of type T to/from a file.
 * @param <T>
 */
public interface Generator<T> {
    T read(File inputFile);

    T defaultInstance();

    void configure(T object);

        when:
        generator.onOutput(complete('status'))

        then:
        0 * target._
    }

    def ignoresProgressEvents() {
        ProgressLogEventGenerator generator = new ProgressLogEventGenerator(target)

        when:
        generator.onOutput(startWithHeader('description'))
        generator.onOutput(progress('tick'))
        generator.onOutput(complete('status'))

        def generator = JavaTestProjectGenerator.values().find { it.projectName == testProject }
        return generator == null ? null : new JavaTestProject(generator)
    }

    @Delegate(interfaces = false)
    private final JavaTestProjectGenerator generator

    private JavaTestProject(JavaTestProjectGenerator generator) {
        this.generator = generator
    }

    @Override

    JvmBlockingTestClassGenerator generator

    def setup() {
        server.start()
        generator = new JvmBlockingTestClassGenerator(testDirectory, server, testFrameworkImports, testFrameworkDependencies, configureTestFramework)
    }

    def "all tests run with #description"() {
        given:
        buildFile.text = generator.initBuildFile()
        buildFile << buildConfig

    this.generator = generator;
    this.collectionSize = collectionSize;
  }

  @Override
  public TestContainerGenerator<T, E> getInnerGenerator() {
    return generator;
  }

  @Override
  public SampleElements<E> samples() {
    return generator.samples();
  }

  @Override
  public T create(Object... elements) {
    return generator.create(elements);

package org.jetbrains.kotlin.analysis.api.fir.generator.rendererrs

import org.jetbrains.kotlin.analysis.api.fir.generator.*
import org.jetbrains.kotlin.fir.checkers.generator.collectClassNamesTo
import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticList
import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticListRenderer
import org.jetbrains.kotlin.fir.checkers.generator.printImports

        this.createdTime = value;
    }

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

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

    public String getPath() {
        checkSpecifiedProperty("path");

        super(taskDependencyFactory);
        this.generator = generator;
        this.coordinates = coordinates;
        this.extension = extension;
        this.type = type;
        this.classifier = classifier;
        this.buildDependencies = taskDependencyFactory.visitingDependencies(context -> {
            context.add(generator.get());
        });
    }

    @Override

    UnixStartScriptGenerator generator = new UnixStartScriptGenerator()

    def "classpath for unix script uses slashes as path separator"() {
        given:
        JavaAppStartScriptGenerationDetails details = createScriptGenerationDetails(null, 'bin')
        Writer destination = new StringWriter()

        when:
        generator.generateScript(details, destination)

        then: