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

	"istio.io/istio/pilot/pkg/networking/util"
	"istio.io/istio/pilot/pkg/security/authz/matcher"
	"istio.io/istio/pilot/pkg/xds/filters"
	"istio.io/istio/pkg/config/security"
	"istio.io/istio/pkg/spiffe"
)

type generator interface {
	permission(key, value string, forTCP bool) (*rbacpb.Permission, error)
	principal(key, value string, forTCP bool, useAuthenticated bool) (*rbacpb.Principal, error)
}

type extendedGenerator interface {

        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

  public void testStringArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generateFresh(String[].class);
    String[] a2 = generator.generateFresh(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }

  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generateFresh(int[].class);

        TermQueryBuilder builder = regTermQ("generator", generator);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setGenerator_NotEqual(String generator) {
        setGenerator_NotTerm(generator, null);
    }

    public void setGenerator_NotTerm(String generator) {
        setGenerator_NotTerm(generator, null);

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

    FreshValueGenerator generator = new FreshValueGenerator();
    generator.addSampleInstances(String.class, ImmutableList.of("a"));
    assertEquals("a", generator.generateFresh(String.class));
    assertEquals("a", generator.generateFresh(String.class));
  }

  public void testAddSampleInstances_noInstance() {
    FreshValueGenerator generator = new FreshValueGenerator();
    generator.addSampleInstances(String.class, ImmutableList.<String>of());