# CI Pipeline Configuration

## Open & import the project

In your IDEA, `File` - `Open`, select `.teamcity/pom.xml`, `import as project`, and you'll have a Maven project.

## Project structure

Mostly a standard Maven project structure. The entry point `settings.kts` defines the TeamCity project.

There are 3 subprojects in the TeamCity project hierarchy: `Check` for Gradle builds, `Promotion` for releasing Gradle versions, `Util` for miscellaneous utilities.

        }
    }
}
// end::cpp-compiler-options-per-variants[]

// tag::cpp-select-target-machines[]
application {
    targetMachines = [
        machines.linux.x86_64,
        machines.windows.x86, machines.windows.x86_64,
        machines.macOS.x86_64
    ]
}

                // If there is a single constructor, and that constructor is public or package private we select it.
                return constructor;
            }
            if (constructor.getAnnotation(Inject.class) != null) {
                // Otherwise, if there is a single constructor that is annotated with `@Inject`, we select it (short-circuit).
                return constructor;
            }
        }

        return configuration;
    }

    @Override
    public Set<File> getFiles() throws ResolveException {
        ResolvedFilesCollectingVisitor visitor = new ResolvedFilesCollectingVisitor();
        visitedArtifacts.select(configuration.getImplicitSelectionSpec()).visitArtifacts(visitor, false);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.getFiles();
    }

    @Override
    @Deprecated

    /**
     * An artifact selection spec that can be applied to a visited artifact set to select
     * the artifacts that a configuration's intrinsic file collection would select.
     */
    ArtifactSelectionSpec getImplicitSelectionSpec();

 * <ul>
 *     <li>Select a variant of the component instance. The variant selected for artifact resolution may be different to that used for graph resolution,
 *     for example when using an {@link org.gradle.api.artifacts.ArtifactView} to select different variants.</li>

 * main branches of the {@link org.gradle.internal.component.resolution.failure.type.ResolutionFailure ResolutionFailure}
 * hierarchy, which represent a failure to select a variant of a component, and a failure to select
 * a configuration by name.
 *
 * Artifact variant selection failures are not represented by a specific exception type, as they are

        }
    }
}
// end::cpp-compiler-options-per-variants[]

// tag::cpp-select-target-machines[]
application {
    targetMachines = listOf(machines.windows.x86, machines.windows.x86_64, machines.macOS.x86_64, machines.linux.x86_64)
}

		s.mu.Unlock()
		<-done
		return ctx.Err()
	}

	ready := make(chan struct{})
	w := waiter{n: n, ready: ready}
	elem := s.waiters.PushBack(w)
	s.mu.Unlock()

	select {
	case <-done:
		s.mu.Lock()
		select {
		case <-ready:
			// Acquired the semaphore after we were canceled.
			// Pretend we didn't and put the tokens back.
			s.cur -= n
			s.notifyWaiters()
		default:

		mu.Lock()
		defer mu.Unlock()
		t1 = time.Now()
		return nil
	}, 100*time.Millisecond)
	dq.Push(func() error {
		mu.Lock()
		defer mu.Unlock()
		t0 = time.Now()
		return nil
	})

	select {
	case <-time.After(500 * time.Millisecond):
	case <-done:
	}

	mu.Lock()
	if !(t2.After(t1) && t1.After(t0)) {
		t.Errorf("expected jobs to be run in order based on delays")
	}
	mu.Unlock()
}