Refactored tests to Kotlin.

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/VersionSet.kt

@@ -30,7 +30,7 @@ class VersionSet(versions: Collection<Version>) {
       return resultSet.map { it.version }
     }
 
-    private class ParsedVersion(val version: Version) : Comparable<ParsedVersion> {
+    internal class ParsedVersion(val version: Version) : Comparable<ParsedVersion> {
         companion object {
             private val dotPattern = Regex("\\.")
             private const val VERSION_SHIFT = 12

buildSrc/src/test/kotlin/datadog/gradle/plugin/muzzle/RangeQueryTest.kt

@@ -0,0 +1,27 @@
+package datadog.gradle.plugin.muzzle
+
+import org.eclipse.aether.artifact.Artifact
+import org.eclipse.aether.artifact.DefaultArtifact
+import org.eclipse.aether.resolution.VersionRangeRequest
+import org.gradle.internal.impldep.org.junit.Assert.assertTrue
+import org.junit.jupiter.api.Test
+
+class RangeQueryTest {
+  private val system = MuzzleMavenRepoUtils.newRepositorySystem()
+  private val session = MuzzleMavenRepoUtils.newRepositorySystemSession(system)
+
+  @Test
+  fun `test range request`() {
+    // compile group: 'org.codehaus.groovy', name: 'groovy-all', version: '2.5.0', ext: 'pom'
+    val directiveArtifact: Artifact = DefaultArtifact("org.codehaus.groovy", "groovy-all", "jar", "[2.5.0,2.5.8)")
+    val rangeRequest = VersionRangeRequest().apply {
+      repositories = MuzzleMavenRepoUtils.MUZZLE_REPOS
+      artifact = directiveArtifact
+    }
+
+    // This call makes an actual network request, which may fail if network access is limited.
+    val rangeResult = system.resolveVersionRange(session, rangeRequest)
+
+    assertTrue(rangeResult.versions.size >= 8)
+  }
+}

buildSrc/src/test/kotlin/datadog/gradle/plugin/muzzle/VersionSetTest.kt

@@ -0,0 +1,102 @@
+package datadog.gradle.plugin.muzzle
+
+import org.eclipse.aether.version.Version
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class VersionSetTest {
+
+  @Test
+  fun `parse versions properly`() {
+    data class Case(
+      val version: Version,
+      val versionNumber: Long,
+      val ending: String
+    )
+
+    val cases = listOf(
+      Case(ver("1.2.3"), num(1, 2, 3), ""),
+      Case(ver("4.5.6-foo"), num(4, 5, 6), "foo"),
+      Case(ver("7.8.9.foo"), num(7, 8, 9), "foo"),
+      Case(ver("10.11.12.foo-bar"), num(10, 11, 12), "foo-bar"),
+      Case(ver("13.14.foo-bar"), num(13, 14, 0), "foo-bar"),
+      Case(ver("15.foo"), num(15, 0, 0), "foo"),
+      Case(ver("16-foo"), num(16, 0, 0), "foo")
+    )
+
+    for (c in cases) {
+      val parsed = VersionSet.ParsedVersion(c.version)
+      assertEquals(c.versionNumber, parsed.versionNumber, "versionNumber for ${c.version}")
+      assertEquals(c.ending, parsed.ending, "ending for ${c.version}")
+      assertEquals(
+        c.versionNumber shr 12,
+        parsed.majorMinor.toLong(),
+        "majorMinor for ${c.version}"
+      )
+    }
+  }
+
+  @Test
+  fun `select low and high from major minor`() {
+    val versionsCases = listOf(
+      listOf(
+        ver("4.5.6"),
+        ver("1.2.3")
+      ),
+      listOf(
+        ver("1.2.3"),
+        ver("1.2.1"),
+        ver("1.3.0"),
+        ver("1.2.7"),
+        ver("1.4.17"),
+        ver("1.4.1"),
+        ver("1.4.0"),
+        ver("1.4.10")
+      )
+    )
+
+    val expectedCases = listOf(
+      listOf(
+        ver("1.2.3"),
+        ver("4.5.6")
+      ),
+      listOf(
+        ver("1.2.1"),
+        ver("1.2.7"),
+        ver("1.3.0"),
+        ver("1.4.0"),
+        ver("1.4.17")
+      )
+    )
+
+    versionsCases.zip(expectedCases).forEach { (versions, expected) ->
+      val versionSet = VersionSet(versions)
+      assertEquals(expected, versionSet.lowAndHighForMajorMinor)
+    }
+  }
+
+  private fun ver(v: String): Version = TestVersion(v)
+
+  private fun num(major: Int, minor: Int, micro: Int): Long {
+    var result = major.toLong()
+    result = (((result shl 12) + minor) shl 12) + micro
+    return result
+  }
+
+  private class TestVersion(private val v: String) : Version {
+    override fun compareTo(other: Version?): Int {
+      if (other is TestVersion) {
+        return v.compareTo(other.v)
+      }
+
+      return 1
+    }
+
+    override fun equals(other: Any?): Boolean =
+      other is TestVersion && v == other.v
+
+    override fun hashCode(): Int = v.hashCode()
+
+    override fun toString(): String = v
+  }
+}