properties = propertiesFactory.create()
        }
        return properties
    }


    List<String> getLatests() {
        def versionList = loadedProperties().getProperty("latests")
        return (versionList == null || versionList.empty) ? [] : versionList.split(",")
    }

    String getLatest() {
        return latests.last()
    }

    List<String> getLatestsStable() {
        return latests

            }
        """
    }

    private List<String> getVersionList(String name) {
        def versionList = loadedProperties().getProperty(name)
        return (versionList == null || versionList.empty) ? [] : versionList.split(",")
    }

    private Properties loadedProperties() {
        if (properties == null) {
            properties = propertiesFactory.create()

        ModuleAtRepositoryKey key = createKey(repository, moduleId);
        ModuleVersionsCacheEntry entry = get(key);
        return entry == null ? null : versionList(entry);
    }

    private CachedModuleVersionList versionList(ModuleVersionsCacheEntry entry) {
        return new DefaultCachedModuleVersionList(
            entry.moduleVersionListing,
            timeProvider.getCurrentTime() - entry.createTimestamp

            if (cachedModuleVersionList != null) {
                Set<String> versionList = cachedModuleVersionList.getModuleVersions();
                Set<ModuleVersionIdentifier> versions = versionList
                    .stream()
                    .map(original -> DefaultModuleVersionIdentifier.newId(moduleId, original))

            }
            if (isName) {
                nameList.add(value);
            } else {
                versionList.add(value);
            }
        }
        return new Artifact(nameList.stream().collect(Collectors.joining("-")), versionList.stream().collect(Collectors.joining("-")), url);
    }

    public void installArtifact(final Artifact artifact) {
        switch (artifact.getType()) {

import org.junit.jupiter.api.Test;

import static java.util.stream.Collectors.toList;
import static org.junit.jupiter.api.Assertions.*;

/**
 */
public class VersionTest extends AbstractVersionTest {
    private final ModelVersionParser modelVersionParser = new DefaultModelVersionParser(new GenericVersionScheme());

    protected Version newVersion(String version) {

VERSION_LIST := 1 2
HUB ?= gcr.io/istio-testing
IMAGE_PREFIX ?= /wasm
IMG := $(HUB)$(IMAGE_PREFIX)/header-injector

all: docker-push

build: plugin.cc plugin.h BUILD WORKSPACE
	rm -f *.wasm
	$(foreach VERSION, $(VERSION_LIST), bazel build :plugin-0.0.$(VERSION).wasm && cp bazel-bin/plugin-0.0.$(VERSION).wasm .;)

docker-build: build

)

func TestCmdVersion(t *testing.T) {
	var versionTest = []struct {
		name     string
		args     string
		regex    string
		expected bool
	}{
		{"invalid output option", "--output=valid", "", false},
		{"short output", "--output=short", ShortExpectedRegex, true},
		{"default output", "", NormalExpectedRegex, true},
	}

	kubeadmPath := getKubeadmPath()
	for _, rt := range versionTest {
		t.Run(rt.name, func(t *testing.T) {

	}

	client.Close()
	wg.Wait()
}

type versionTest struct {
	supported map[string]bool // protocol -> binary
	requested []string
	error     bool
	expected  string
}

func versionTests() []versionTest {
	const (
		binary = true
		base64 = false
	)
	return []versionTest{
		{
			supported: nil,
			requested: []string{"raw"},
			error:     true,
		},

			var size uint64
			var objectsCount uint64
			var objectsHist, versionsHist map[string]uint64
			if !dataUsageInfo.LastUpdate.IsZero() {
				size = dataUsageInfo.BucketsUsage[bucket.Name].Size
				objectsCount = dataUsageInfo.BucketsUsage[bucket.Name].ObjectsCount
				objectsHist = dataUsageInfo.BucketsUsage[bucket.Name].ObjectSizesHistogram
				versionsHist = dataUsageInfo.BucketsUsage[bucket.Name].ObjectVersionsHistogram
			}