path: root/doc-tool/test/UsecaseTest.scala

package dotty.tools
package dottydoc

import org.junit.Test
import org.junit.Assert._

import dotc.util.SourceFile
import model._
import model.internal._
import model.references._
import util.syntax._

class UsecaseTest extends DottyDocTest {
  @Test def simpleUsecase = {
    val source = new SourceFile(
      "DefWithUseCase.scala",
      """
      |package scala
      |
      |trait Test[A] {
      |  /** Definition with a "disturbing" signature
      |   *
      |   *  @usecase def foo: A
      |   */
      |  def foo[B]: A => B
      |}
      """.stripMargin
    )

    checkSources(source :: Nil) { packages =>
      packages("scala") match {
        case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
          val List(foo: Def) = trt.members

          assert(foo.comment.isDefined, "Lost comment in transformations")

          val returnValue = foo.returnValue match {
            case ref: TypeReference => ref.title
            case _ =>
              assert(
                false,
                "Incorrect return value after usecase transformation"
              )
              ""
          }

          assert(
            foo.typeParams.isEmpty,
            "Type parameters were not stripped by usecase"
          )
          assert(returnValue == "A", "Incorrect return type after usecase")

          assert(foo.name == "foo", s"Incorrect name after transform: ${foo.name}")
      }
    }
  }

  @Test def simpleUsecaseAddedArg = {
    val source = new SourceFile(
      "DefWithUseCase.scala",
      """
      |package scala
      |
      |trait Test[A] {
      |  /** Definition with a "disturbing" signature
      |   *
      |   *  @usecase def foo(a: A): A
      |   */
      |  def foo[B]: A => B
      |}
      """.stripMargin
    )

    checkSources(source :: Nil) { packages =>
      packages("scala") match {
        case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
          val List(foo: Def) = trt.members

          val returnValue = foo.returnValue match {
            case ref: TypeReference => ref.title
            case _ =>
              assert(
                false,
                "Incorrect return value after usecase transformation"
              )
              ""
          }

          assert(
            foo.typeParams.isEmpty,
            "Type parameters were not stripped by usecase"
          )
          assert(returnValue == "A", "Incorrect return type after usecase")
          assert(
            foo.paramLists.head.list.head.title == "a",
            "Incorrect parameter to function after usecase transformation"
          )
          assert(foo.name == "foo", s"Incorrect name after transform: ${foo.name}")
      }
    }
  }

  @Test def simpleTparamUsecase = {
    val source = new SourceFile(
      "DefWithUseCase.scala",
      """
      |package scala
      |
      |trait Test[A] {
      |  /** Definition with a "disturbing" signature
      |   *
      |   *  @usecase def foo[C]: A
      |   */
      |  def foo[B]: A => B
      |}
      """.stripMargin
    )

    checkSources(source :: Nil) { packages =>
      packages("scala") match {
        case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
          val List(foo: Def) = trt.members

          val returnValue = foo.returnValue match {
            case ref: TypeReference => ref.title
            case _ =>
              assert(
                false,
                "Incorrect return value after usecase transformation"
              )
              ""
          }

          assert(
            foo.typeParams.nonEmpty,
            "Type parameters were incorrectly stripped by usecase"
          )

          assert(foo.typeParams.head == "C", "Incorrectly switched tparam")
          assert(returnValue == "A", "Incorrect return type after usecase")

          assert(foo.name == "foo", s"Incorrect name after transform: ${foo.name}")
      }
    }
  }

  @Test def expandColl = {
    val source = new SourceFile(
      "ExpandColl.scala",
      """
      |package scala
      |
      |/** The trait $Coll
      | *
      | *  @define Coll Iterable
      | */
      |trait Iterable[A] {
      |  /** Definition with a "disturbing" signature
      |   *
      |   *  @usecase def map[B](f: A => B): $Coll[B]
      |   */
      |  def map[B, M[B]](f: A => B): M[B] = ???
      |}
      """.stripMargin
    )

    checkSources(source :: Nil) { packages =>
      packages("scala") match {
      case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
        val List(map: Def) = trt.members

        val returnValue = map.returnValue match {
          case ref: TypeReference => ref.title
          case _ =>
            assert(
              false,
              "Incorrect return value after usecase transformation"
            )
            ""
        }

        assert(
          returnValue == "Iterable",
          "Incorrect return type after usecase transformation"
        )
      }
    }
  }

  @Test def checkStripping = {
    val source = new SourceFile(
      "CheckStripping.scala",
      """
      |package scala
      |
      |/** The trait $Coll
      | *
      | *  @define Coll Iterable
      | */
      |trait Iterable[A] {
      |  /** Definition with a "disturbing" signature
      |   *
      |   *  @usecase def map[B](f: A => B): $Coll[B]
      |   */
      |  def map[B, M[B]](f: A => B): M[B] = ???
      |}
      """.stripMargin
    )

    checkSources(source :: Nil) { packages =>
      packages("scala") match {
      case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
        val List(map: Def) = trt.members
        assert(map.comment.isDefined, "Lost comment in transformations")

        val docstr = ctx.docbase.docstring(map.symbol).get.raw
        assert(
          !docstr.contains("@usecase"),
          s"Comment should not contain usecase after stripping, but was:\n$docstr"
        )
      }
    }
  }

  @Test def checkIterator =
    checkFiles("../scala-scala/src/library/scala/collection/Iterator.scala" :: Nil) { _ =>
      // success if typer throws no errors! :)
    }

  @Test def checkIterableLike =
    checkFiles("../scala-scala/src/library/scala/collection/IterableLike.scala" :: Nil) { _ =>
      // success if typer throws no errors! :)
    }
}