when:
        def id = generator.generateId()
        def id2 = other.generateId()

        then:
        id != id2

        and:
        2 * target.generateId() >> 12
    }

    def compositeIdsAreEqualWhenOriginalIdsAreEqual() {
        when:
        def id = generator.generateId()
        def id2 = generator.generateId()

        then:
        id == id2

        and:

        when:
        generator.gradleCommand = 'GRADLE'
        generator.visualStudioVersion = VersionNumber.parse("14.0")
        generator.addConfiguration(configuration("debugWin32", "Win32", ["foo", "bar"], ["include1", "include2"]))
        generator.addConfiguration(configuration("releaseWin32", "Win32", ["foo", "bar"], ["include1", "include2", "include3"]))

        }

        when:
        generator.generate()

        then:
        1 * generator.xmlWriter.write(fooTest, _)
        1 * generator.xmlWriter.write(barTest, _)
        0 * generator.xmlWriter._

        where:
        numThreads << [1, 4]
    }

    def "adds context information to the failure if something goes wrong"() {
        generator = generatorWithMaxThreads(1)

    def defaultType = generator("default")
    def converter = converter("maven")
    def registry = new ProjectLayoutSetupRegistry(defaultType, converter, Mock(TemplateOperationFactory))

    def "can add multiple descriptors"() {
        when:
        registry.add(generator("desc1"))
        registry.add(generator("desc2"))
        registry.add(generator("desc3"))

        then:

        def generator = new ClientBuildEventGenerator(consumer, subscriptions, [mapper1, mapper2], fallback)

        when:
        generator.started(operation, startEvent)

        then:
        0 * _

        when:
        generator.progress(operationId, progressEvent)

        then:
        0 * _

        when:
        generator.finished(operation, finishEvent)

    implementation(project(":compiler:fir:tree:tree-generator"))
    implementation(project(":compiler:fir:checkers:checkers-component-generator"))
    implementation(project(":analysis:analysis-api"))

    implementation(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }

    /*

import org.gradle.api.tasks.PathSensitivity;
import org.gradle.api.tasks.TaskAction;
import org.gradle.internal.MutableActionSet;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.plugins.ide.internal.generator.generator.Generator;
import org.gradle.work.DisableCachingByDefault;

import javax.annotation.Nullable;
import javax.inject.Inject;
import java.io.File;

/**

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

        def generator = new ProblematicClassGenerator(className, sourceSet)
        generator.addError()
        generator.addError()
        return generator.save()
    }

    TestFile writeJavaCausingTwoCompilationWarnings(String className) {
        def generator = new ProblematicClassGenerator(className)
        generator.addWarning()
        generator.addWarning()
        return generator.save()

class LongIdGeneratorTest {
    private final LongIdGenerator generator = new LongIdGenerator()

    @Rule
    public MultithreadedTestRule parallel = new MultithreadedTestRule();

    @Test
    void generatesMonotonicallyIncreasingLongIdsStartingAtOne() {
        assertThat(generator.generateId(), equalTo(1L))
        assertThat(generator.generateId(), equalTo(2L))
        assertThat(generator.generateId(), equalTo(3L))
    }

    @Test