res[i] = Name(i + 1)
		}
		return res
	default:
		return []Name{name}
	}
}

// Mask returns the type as mask.
// Compound "All" types are expanded.
func (name Name) Mask() uint64 {
	if name < objectSingleTypesEnd {
		return 1 << (name - 1)
	}
	var mask uint64
	for _, n := range name.Expand() {
		mask |= 1 << (n - 1)
	}
	return mask
}

	Name  string
	Field *Field
}

func (uni *UniqueConstraint) GetName() string { return uni.Name }

func (uni *UniqueConstraint) Build() (sql string, vars []interface{}) {
	return "CONSTRAINT ? UNIQUE (?)", []interface{}{clause.Column{Name: uni.Name}, clause.Column{Name: uni.Field.DBName}}
}

// ParseUniqueConstraints parse schema unique constraints
func (schema *Schema) ParseUniqueConstraints() map[string]UniqueConstraint {

            getName(testCoverage),
            getDescription(testCoverage),
            testCoverage,
            stage,
            parallelizationMethod,
            subprojects.map { it.name },
        )

    override fun getName(testCoverage: TestCoverage) =
        truncateName("${testCoverage.asName()} (${subprojects.joinToString(",") { it.name }})")

                "value": 80
              }
            ]
          },
          "unit": "bytes"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "Replication Errors"
            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-red",

                "value": 80
              }
            ]
          },
          "unit": "short"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "Replication Errors"
            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-red",

	}

	if stmt.Schema != nil {
		for _, field := range stmt.Schema.FieldsByName {
			name := field.DBName
			if name == "" {
				name = field.Name
			}

			if requireCreate && !field.Creatable {
				results[name] = false
			} else if requireUpdate && !field.Updatable {
				results[name] = false
			}
		}
	}

	return results, !notRestricted && len(stmt.Selects) > 0

		if err == nil {
			devName := ""
			diskstats, _ := bfs.ProcDiskstats()
			for _, dstat := range diskstats {
				// ignore all loop devices
				if strings.HasPrefix(dstat.DeviceName, "loop") {
					continue
				}
				if dstat.MajorNumber == info.Major && dstat.MinorNumber == info.Minor {
					devName = dstat.DeviceName
					break
				}
			}
			if devName != "" {
				info.Name = devName

        }
    })

class FlakyTestQuarantineProject(
    model: CIBuildModel,
    stage: Stage,
    val os: Os,
) : Project({
        id("${model.projectId}_FlakyQuarantine_${os.asName()}")
        name = "Flaky Test Quarantine - ${os.asName()}"

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }
            .flatMap { it.functionalTests }

import jetbrains.buildServer.configs.kotlin.ParameterDisplay

class RerunFlakyTest(
    os: Os,
    arch: Arch = Arch.AMD64,
) : BuildType({
        val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
        name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"
        description = "Allows you to rerun a selected flaky test 10 times"
        id(id)
        val testJvmVendorParameter = "testJavaVendor"

            String jarName = dependency.getName();
            String depName = regex.matcher(jarName).replaceFirst("");

            validateSha(shaFiles, dependency, jarName, depName);

            String dependencyName = getDependencyName(mappings, depName);
            logger.info("mapped dependency name {} to {} for license/notice check", depName, dependencyName);