kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
mockserver = { module = "org.testcontainers:mockserver", version.ref = "testcontainers" }
mockserver-client = { module = "org.mock-server:mockserver-client-java-no-dependencies", version.ref = "mockserverClient" }

		_, err = dst.unmarshalV(x.metaV, version.meta)
		if err != nil {
			return versions, err
		}
		fi, err := dst.ToFileInfo(volume, path, allParts)
		if err != nil {
			return versions, err
		}
		fi.NumVersions = len(x.versions)
		versions = append(versions, fi)
	}

	for i := range versions {
		versions[i].NumVersions = len(versions)
		if i > 0 {

    protected static final int X_EQ_Y = 0;

    protected static final int X_GT_Y = 1;

    protected abstract Version newVersion(String version);

    protected void assertOrder(int expected, String version1, String version2) {
        Version v1 = newVersion(version1);
        Version v2 = newVersion(version2);

        if (expected > 0) {
            assertEquals(1, Integer.signum(v1.compareTo(v2)), "expected " + v1 + " > " + v2);

                                        if (versions == null) {
                                            versions = source.retrieveAvailableVersions(metadataRequest);
                                            artifact.setAvailableVersions(versions);
                                        }

                                        Collections.sort(versions);

    }

    private void assertNotContains(VersionConstraint c, String... versions) {
        assertContains(String.format("%s: %%s should not be contained\n", c.toString()), c, false, versions);
    }

    private void assertContains(String msg, VersionConstraint c, boolean b, String... versions) {
        for (String v : versions) {
            assertEquals(b, c.contains(versionParser.parseVersion(v)), String.format(msg, v));

                VersionsMetadata versionsMetadata = versions.get(key);
                if (versionsMetadata == null) {
                    versionsMetadata = new VersionsMetadata(artifact, timestamp);
                    versions.put(key, versionsMetadata);
                }
            }
        }

        return versions.values();
    }

        }

        for (Artifact artifact : artifacts) {
            String version = artifact.getVersion();

            if (version.endsWith(SNAPSHOT)) {
                String qualifier = snapshot.getTimestamp() + '-' + snapshot.getBuildNumber();
                version = version.substring(0, version.length() - SNAPSHOT.length()) + qualifier;
            }

    };

    private void checkVersionsOrder(String[] versions) {
        Comparable[] c = new Comparable[versions.length];
        for (int i = 0; i < versions.length; i++) {
            c[i] = newComparable(versions[i]);
        }

        for (int i = 1; i < versions.length; i++) {
            Comparable low = c[i - 1];
            for (int j = i; j < versions.length; j++) {
                Comparable high = c[j];

	Size      int64
	Objects   uint64
	Versions  uint64 // Versions that are not delete markers.
	ObjSizes  sizeHistogram
	Compacted bool
}

//msgp:tuple dataUsageEntryV6
type dataUsageEntryV6 struct {
	Children dataUsageHashMap
	// These fields do no include any children.
	Size      int64
	Objects   uint64
	Versions  uint64 // Versions that are not delete markers.
	ObjSizes  sizeHistogram

<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>org.apache.maven.its</groupId>
  <artifactId>a</artifactId>
  <version>0.1</version>
  <versioning>
    <versions>
      <version>0.1</version>
    </versions>
    <lastUpdated>20091023222756</lastUpdated>
  </versioning>