JETBRAINS("jetbrains", "JetBrains"),
        MICROSOFT("microsoft", "Microsoft"),
        ORACLE("oracle", "Oracle"),
        SAP("sap se", "SAP SapMachine"),
        TENCENT("tencent", "Tencent"),
        UNKNOWN("gradle", "Unknown Vendor");

        private final String indicatorString;
        private final Pattern indicatorPattern;
        private final String displayName;

    public static final JvmVendorSpec SAP = matching(KnownJvmVendor.SAP);

    /**
     * A constant for using <a href="https://tencent.github.io/konajdk">Tencent Kona JDK</a> as the JVM vendor.
     *
     * @since 8.6
     */
    @Incubating
    public static final JvmVendorSpec TENCENT = matching(KnownJvmVendor.TENCENT);

    /**
     * Determines if the vendor passed as an argument matches this spec.
     * @param vendor the vendor to test

        where:
        vendor << ["ADOPTIUM", "ADOPTOPENJDK", "AMAZON", "APPLE", "AZUL", "BELLSOFT", "GRAAL_VM", "HEWLETT_PACKARD", "IBM", "JETBRAINS", "MICROSOFT", "ORACLE", "SAP", "TENCENT", "UNKNOWN"]
    }

    @NotYetImplemented
    def "When execute updateDaemonJvm for valid implementation option Then build properties are populated with expected values"() {
        when:

            "[ADOPTIUM, ADOPTOPENJDK, AMAZON, APPLE, AZUL, BELLSOFT, GRAAL_VM, HEWLETT_PACKARD, IBM, JETBRAINS, MICROSOFT, ORACLE, SAP, TENCENT, UNKNOWN]")
    }

    @NotYetImplemented
    def "Given unexpected toolchain implementation When execute any task Then fails with expected exception message"() {
        given:

#include <sys/thread.h>
#include <sys/resource.h>

#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
*/
import "C"

const (
	_EPERM     = C.EPERM
	_ENOENT    = C.ENOENT
	_EINTR     = C.EINTR
	_EAGAIN    = C.EAGAIN
	_ENOMEM    = C.ENOMEM
	_EACCES    = C.EACCES
	_EFAULT    = C.EFAULT
	_EINVAL    = C.EINVAL
	_ETIMEDOUT = C.ETIMEDOUT

	_PROT_NONE  = C.PROT_NONE

package main

func f() {
	var m Mutex
	c := MakeCond(&m)
	percent := 0
	const step = 10
	for i := 0; i < 5; i++ {
		go func() {
			for {
				// Emulates some useful work.
				time.Sleep(1e8)
				m.Lock()
				defer
				if /* ERROR "expected ';', found 'if'" */ percent == 100 {
					m.Unlock()
					break
				}
				percent++
				if percent % step == 0 {
					//c.Signal()
				}
				m.Unlock()
			}

        super(taskDependencyFactory);
        this.resultProvider = resultProvider;
        this.lenient = lenient;
        this.resolutionHost = resolutionHost;
    }

    public ResolutionHost getResolutionHost() {
        return resolutionHost;
    }

    public boolean isLenient() {
        return lenient;
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {

    private final String name;
    private final String base;
    private final boolean lenient;

    public AdditionalVariant(String name) {
        this(name, null, false);
    }

    public AdditionalVariant(String name, @Nullable String base, boolean lenient) {
        this.name = name;
        this.base = base;
        this.lenient = lenient;
    }

    public String getName() {
        return name;
    }

    private final boolean lenient;
    private final CalculatedValue<ArtifactSetResult> result;

    public DefaultArtifactCollection(ResolutionBackedFileCollection files, boolean lenient, ResolutionHost resolutionHost, CalculatedValueFactory calculatedValueFactory) {
        this.fileCollection = files;
        this.lenient = lenient;

     */
    InstantiationScheme decorateScheme();

    /**
     * Creates an {@link Instantiator} that decorates the instances created.
     * The returned {@link Instantiator} is lenient when there is a missing {@link javax.inject.Inject} annotation or null constructor parameters,
     * for backwards compatibility.