Add tests for external location providing

Author: pikinier20

scala3doc/src/dotty/dokka/location/ScalaExternalLocationProvider.scala

@@ -18,17 +18,18 @@ class ScalaExternalLocationProvider(
   externalDocumentation: ExternalDocumentation,
   extension: String,
   kind: DocumentationKind
-)(using ctx: DokkaContext) extends DefaultExternalLocationProvider(externalDocumentation, extension, ctx):
+) extends ExternalLocationProvider:
+  def docURL = externalDocumentation.getDocumentationURL.toString.stripSuffix("/") + "/"
   override def resolve(dri: DRI): String =
     Option(externalDocumentation.getPackageList).map(_.getLocations.asScala.toMap).flatMap(_.get(dri.toString))
       .fold(constructPath(dri))( l => {
-        this.getDocURL + l
+        this.docURL + l
       }
     )
 
   private val originRegex = raw"\[origin:(.*)\]".r
 
-  override def constructPath(dri: DRI): String = kind match {
+  def constructPath(dri: DRI): String = kind match {
     case DocumentationKind.Javadoc => constructPathForJavadoc(dri)
     case DocumentationKind.Scaladoc => constructPathForScaladoc(dri)
     case DocumentationKind.Scala3doc => constructPathForScala3doc(dri)
@@ -38,17 +39,17 @@ class ScalaExternalLocationProvider(
     val location = "\\$+".r.replaceAllIn(dri.location.replace(".","/"), _ => ".")
     val origin = originRegex.findFirstIn(dri.extra)
     val anchor = dri.anchor
-    getDocURL + location + extension + anchor.fold("")(a => s"#$a")
+    docURL + location + extension + anchor.fold("")(a => s"#$a")
   }
 
   private def constructPathForScaladoc(dri: DRI): String = {
     val location = dri.location.replace(".","/")
     val anchor = dri.anchor
-    getDocURL + location + extension + anchor.fold("")(a => s"#$a")
+    docURL + location + extension + anchor.fold("")(a => s"#$a")
   }
 
   private def constructPathForScala3doc(dri: DRI): String = {
     val location = dri.location.replace(".","/")
     val anchor = dri.anchor
-    getDocURL + location + anchor.fold(extension)(a => s"/$a$extension")
+    docURL + location + anchor.fold(extension)(a => s"/$a$extension")
   }

scala3doc/test/dotty/dokka/ExternalLocationProviderTest.scala

@@ -0,0 +1,76 @@
+package dotty.dokka
+
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.pages.ModulePage
+import org.jetbrains.dokka.pages.ClasslikePageNode
+import org.jetbrains.dokka.model.DPackage
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.base.resolvers.external._
+import org.jetbrains.dokka.base.resolvers.shared.{ExternalDocumentation => ED, _}
+import org.jetbrains.dokka.base.resolvers.local._
+import org.jetbrains.dokka.model.DisplaySourceSet
+import dotty.dokka.withNoOrigin
+import dotty.dokka.tasty._
+
+import scala.collection.JavaConverters._
+import java.nio.file.Paths
+import java.nio.file.Path
+import scala.util.matching._
+import dotty.dokka.model.api._
+import java.net.URL
+import org.junit.{Test}
+import org.junit.Assert._
+
+import scala.quoted._
+
+class ExternalLocationProviderTest:
+  def createExternalLocationProvider(docURL: String, ext: String, kind: DocumentationKind) = {
+    val emptyExtDoc = ED(
+          URL(docURL),
+          PackageList(
+            RecognizedLinkFormat.Javadoc1, JSet(), JMap(), URL(docURL)
+          )
+        )
+    ScalaExternalLocationProvider(emptyExtDoc, ext, kind)
+  }
+
+  def testResolvedLinks(provider: ScalaExternalLocationProvider, testcases: List[(DRI, String)]) = testcases.foreach {
+    case (dri, expect) => assertEquals(provider.resolve(dri), expect)
+  }
+
+  @Test
+  def javadocExternalLocationProviderTest(): Unit = {
+    val provider = createExternalLocationProvider("https://docs.oracle.com/javase/8/docs/api/", ".html", DocumentationKind.Javadoc)
+    val testcases = List(
+      (DRI("java.util.Map$$Entry"), "https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html"),
+      (DRI("javax.swing.plaf.nimbus.AbstractRegionPainter$$PaintContext$$CacheMode"), "https://docs.oracle.com/javase/8/docs/api/javax/swing/plaf/nimbus/AbstractRegionPainter.PaintContext.CacheMode.html"),
+      (DRI("java.lang.CharSequence"), "https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html")
+    )
+    testResolvedLinks(provider, testcases)
+  }
+
+  @Test
+  def scaladocExternalLocationProviderTest(): Unit = {
+    val provider = createExternalLocationProvider("https://www.scala-lang.org/api/current/", ".html", DocumentationKind.Scaladoc)
+    val testcases = List(
+      (DRI("scala.Predef$"),"https://www.scala-lang.org/api/current/scala/Predef$.html"),
+      (DRI("scala.util.package$$chaining$"), "https://www.scala-lang.org/api/current/scala/util/package$$chaining$.html"),
+      (DRI("scala.util.Using$"), "https://www.scala-lang.org/api/current/scala/util/Using$.html"),
+      (DRI("scala.util.matching.Regex$$Match"), "https://www.scala-lang.org/api/current/scala/util/matching/Regex$$Match.html")
+    )
+    testResolvedLinks(provider, testcases)
+  }
+
+  @Test
+  def scala3docExternalLocationProviderTest(): Unit = {
+    val provider = createExternalLocationProvider("https://dotty.epfl.ch/api/", ".html", DocumentationKind.Scala3doc)
+    val testcases = List(
+      (DRI("scala.Predef$"),"https://dotty.epfl.ch/api/scala/Predef$.html"),
+      (DRI("scala.util.package$$chaining$"), "https://dotty.epfl.ch/api/scala/util/package$$chaining$.html"),
+      (DRI("scala.util.Using$"), "https://dotty.epfl.ch/api/scala/util/Using$.html"),
+      (DRI("scala.util.matching.Regex$$Match"), "https://dotty.epfl.ch/api/scala/util/matching/Regex$$Match.html")
+    )
+    testResolvedLinks(provider, testcases)
+  }