"10"              | null
    }

    private VisualStudioProjectConfiguration configuration(def configName, def platformName, def defines, def includes) {
        return Stub(VisualStudioProjectConfiguration) {
            getName() >> "${configName}|${platformName}"
            getConfigurationName() >> configName
            getPlatformName() >> platformName
            getTargetBinary() >> Stub(VisualStudioTargetBinary) {

        map.put(ConfigName.CONFIG, configConfigMap);
        map.put(ConfigName.CLIENT, clientConfigMap);
        map.put(ConfigName.XPATH, xpathConfigMap);
        map.put(ConfigName.META, metaConfigMap);
        map.put(ConfigName.VALUE, valueConfigMap);
        map.put(ConfigName.SCRIPT, scriptConfigMap);
        map.put(ConfigName.FIELD, fieldConfigMap);

            on { add(any(), any()) } doReturn publishArtifact
        }
        val artifacts = ArtifactHandlerScope.of(artifactHandler)
        val configuration: Configuration = mock {
            on { name } doReturn "configName"
        }
        val firstNotation = "a:b:c"
        val secondNotation = "d:e:f"

        lateinit var firstArtifact: PublishArtifact
        lateinit var secondArtifact: PublishArtifact
        artifacts {

    String getConfigId();

    Integer getTimeToLive();

    CrawlerClientFactory initializeClientFactory(Supplier<CrawlerClientFactory> creator);

    Map<String, String> getConfigParameterMap(ConfigName name);

    default void initializeDefaultHttpProxy(final Map<String, Object> paramMap) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String proxyHost = fessConfig.getHttpProxyHost();

    def exeBinary = Mock(VisualStudioTargetBinary)
    def configuration = new VisualStudioProjectConfiguration(null,"configName", exeBinary)

    def "configuration has supplied names"() {
        expect:
        configuration.configurationName == "configName"
        configuration.name == "configName|Win32"
    }

	}{
		{"VirtualService", configName, collections.VirtualService, ExampleVirtualService},
		{"DestinationRule", configName, collections.DestinationRule, ExampleDestinationRule},
		{"ServiceEntry", configName, collections.ServiceEntry, ExampleServiceEntry},
		{"Gateway", configName, collections.Gateway, ExampleGateway},
		{"AuthorizationPolicy", configName, collections.AuthorizationPolicy, ExampleAuthorizationPolicy},
	}

        // from config
        final String scriptType = crawlingConfig.getScriptType();
        final Map<String, String> scriptConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.SCRIPT);
        final Map<String, String> metaConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.META);
        for (final Map.Entry<String, String> entry : metaConfigMap.entrySet()) {
            final String key = entry.getKey();

    }

    protected String crawlingConfigInternal(final CrawlingConfigForm form) {

        String configName = form.crawlingConfigName;
        String configPath = form.crawlingConfigPath.trim();
        if (StringUtil.isBlank(configName)) {
            configName = StringUtils.abbreviate(configPath, 30);
        }

        // normalize
        final StringBuilder buf = new StringBuilder(1000);

        String configName = getConfigurationName(suffix);
        Configuration configuration = create
            ? project.getConfigurations().maybeCreateDependencyScopeUnlocked(configName, warnOnDuplicate)
            : project.getConfigurations().getByName(configName);
        configuration.setDescription(kind + " dependencies for the '" + name + "' feature.");

		return cached, k8sConfigCache[input]
	}
	configName := input.ConfigName
	if configName == "" {
		configName = input.Name
	}
	tmpl := template.Must(template.New("").Funcs(sprig.TxtFuncMap()).ParseFiles(path.Join("testdata", "benchmarks", configName+".yaml")))
	var buf bytes.Buffer
	if err := tmpl.ExecuteTemplate(&buf, configName+".yaml", input); err != nil {
		t.Fatalf("failed to execute template: %v", err)