// Configs implements StorageFactory.
func (s *DefaultStorageFactory) Configs() []storagebackend.Config {
	return configs(s.StorageConfig, s.Overrides)
}

// Configs gets configurations for all of registered storage destinations.
func Configs(storageConfig storagebackend.Config) []storagebackend.Config {
	return configs(storageConfig, nil)
}

// Returns all storage configurations including those for group resource overrides

			assert.Equal(t, original, after, "mesh config should not be mutated")
		})
	}
}

func newProxyConfig(name, ns string, spec config.Spec) config.Config {
	return config.Config{
		Meta: config.Meta{
			GroupVersionKind: gvk.ProxyConfig,
			Name:             name,
			Namespace:        ns,
		},
		Spec: spec,
	}
}

func newProxyConfigStore(t *testing.T, configs []config.Config) ConfigStore {
	t.Helper()

				// minIstioVersion allows conditionally skipping based on required version
				minIstioVersion string
			}{
				{
					name: "global mtls strict",
					configs: config.Sources{
						config.File("testdata/reachability/global-peer-authn.yaml.tmpl"),
						config.File("testdata/reachability/global-dr.yaml.tmpl"),
					}.WithParams(param.Params{
						mtlsModeParam:            model.MTLSStrict.String(),

import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.DslContext

fun DslContext.initForTest() {
    // Set the project id here, so we can use methods on the DslContext
    parentProjectId = AbsoluteId("Gradle")
    projectId = AbsoluteId("Gradle_Master")
    settingsRootId = AbsoluteId("GradleMaster")
    settingsRoot.name = "GradleMaster"
    addParameters("Branch" to "master")

	for i := range configs {
		refs[i] = &configs[i]
		refs[i].Domain = domainSuffix
	}
	return refs, err
}

// byKey is an array of config objects that is capable or sorting by Namespace, GroupVersionKind, and Name.
type byKey []*config.Config

func (rs byKey) Len() int {
	return len(rs)
}

func (rs byKey) Swap(i, j int) {
	rs[i], rs[j] = rs[j], rs[i]
}

apiVersion: skaffold/v2beta22
kind: Config
metadata:
  name: prometheus
requires:
  - configs: [istiod]
deploy:
  kubectl:
    manifests: ["../../../samples/addons/prometheus.yaml"]
---
apiVersion: skaffold/v2beta22
kind: Config
metadata:
  name: kiali
requires:
  - configs: [prometheus]
deploy:
  helm:
    releases:
      - name: kiali-server

import jetbrains.buildServer.configs.kotlin.BuildFeatures
import jetbrains.buildServer.configs.kotlin.BuildStep.ExecutionMode
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ProjectFeatures
import jetbrains.buildServer.configs.kotlin.RelativeId
import jetbrains.buildServer.configs.kotlin.buildFeatures.PullRequests

	drs := t.destinationRule.GetFrom()
	configs := make([]model.ConfigHash, 0, len(drs)+1+len(t.envoyFilterKeys))
	if t.destinationRule != nil {
		for _, dr := range drs {
			configs = append(configs, model.ConfigKey{Kind: kind.DestinationRule, Name: dr.Name, Namespace: dr.Namespace}.HashCode())
		}
	}
	if t.service != nil {

import common.Os
import common.paramsForBuildToolBuild
import common.requiresNotEc2Agent
import common.requiresOs
import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.CheckoutMode

abstract class BasePromotionBuildType(vcsRootId: String, cleanCheckout: Boolean = true) : BuildType() {
    init {
        vcs {

    if (function.getName() == entry_func_id &&
        !configs.export_entry_func_to_flib) {
      entry_func.emplace(function);
    } else {
      TF_RETURN_IF_ERROR(ConvertLibFunction(configs, tf_dialect, symbol_table,
                                            function, &temp_flib_def,
                                            visited_functions));
    }
  }

  if (!configs.export_entry_func_to_flib) {