import common.gradleWrapper
import common.javaHome
import common.requiresOs
import common.uuidPrefix
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.DslContext
import vcsroots.useAbsoluteVcs

object PublishKotlinDslPlugin : BuildType({
    name = "Publish Kotlin DSL Plugin"
    id("Util_PublishKotlinDslPlugin")
    uuid = "${DslContext.uuidPrefix}_Util_PublishKotlinDslPlugin"

            }
            if (isGhActions) {
                tag("GH_ACTION")
            }
            whenEnvIsSet("BUILD_TYPE_ID") { buildType ->
                value(tcBuildTypeName, buildType)
                link("Build Type Scans", customValueSearchUrl(mapOf(tcBuildTypeName to buildType)))
            }
        }
    }
    if (isCodeQl) {
        buildScan {
            tag("CODEQL")
        }
    }

import common.buildToolGradleParameters
import common.gradleWrapper
import common.javaHome
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.buildFeatures.freeDiskSpace
import vcsroots.useAbsoluteVcs

object WarmupEc2Agent : BuildType({
    name = "Warmup EC2 Agent"
    id("Util_WarmupEc2Agent")

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().vcsRootId())

    def namingScheme = DefaultBinaryNamingScheme.component("main").withBinaryType("sharedLibrary")
    final toolChain = Stub(NativeToolChainInternal)
    final platform = Stub(NativePlatform)
    final buildType = Stub(BuildType)
    final resolver = Stub(NativeDependencyResolver)
    def sharedLibraryFile = Mock(File)
    def sharedLibraryLinkFile = Mock(File)

    def "has useful string representation"() {
        expect:

    void setFlavor(Flavor flavor);

    void setToolChain(NativeToolChain toolChain);

    void setTargetPlatform(NativePlatform targetPlatform);

    void setBuildType(BuildType buildType);

    Tool getToolByName(String name);

    PlatformToolProvider getPlatformToolProvider();

    void setPlatformToolProvider(PlatformToolProvider toolProvider);

        to.attribute(artifactType, 'aar')

        from.attribute(buildType, 'default')
        to.attribute(buildType, 'release')
    }

    registerTransform(AarDebug) {
        from.attribute(artifactType, 'jar')
        to.attribute(artifactType, 'aar')

        from.attribute(buildType, 'default')
        to.attribute(buildType, 'debug')
    }

    registerTransform(AarClasses) {

 */

package org.gradle.nativeplatform;

import org.gradle.api.Incubating;
import org.gradle.api.NamedDomainObjectContainer;

/**
 * A container of {@link BuildType}s.
 */
@Incubating
public interface BuildTypeContainer extends NamedDomainObjectContainer<BuildType> {

    def namingScheme = DefaultBinaryNamingScheme.component("main").withBinaryType("staticLibrary")
    def toolChain = Stub(NativeToolChainInternal)
    def platform = Stub(NativePlatform)
    def buildType = Stub(BuildType)
    final resolver = Stub(NativeDependencyResolver)
    final outputFile = Mock(File)

 */

package common

import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.buildSteps.script

fun BuildType.applyPerformanceTestSettings(os: Os = Os.LINUX, arch: Arch = Arch.AMD64, timeout: Int = 30) {
    applyDefaultSettings(os = os, arch = arch, timeout = timeout)
    artifactRules = """

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.nativeplatform.internal;

import org.gradle.nativeplatform.BuildType;

public class DefaultBuildType implements BuildType {
    private final String name;

    public DefaultBuildType(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;