Skip to content

Commit

Permalink
Add tests for run function generation; Extract tests data to a separa…
Browse files Browse the repository at this point in the history
…te object
  • Loading branch information
KacperFKorban committed Mar 24, 2024
1 parent 90f6132 commit d35fda7
Show file tree
Hide file tree
Showing 3 changed files with 275 additions and 94 deletions.
102 changes: 8 additions & 94 deletions guinep/src/test/scala/formgentests.scala
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@ package tests
import guinep.model.*

class FormGenTests extends munit.FunSuite {
import FormGenTests.*
import TestsData.*

inline def checkGeneratedFormEquals(name: String, inline f: Any, expected: Form): Unit =
test(s"generate correct form for function $name") {
Expand Down Expand Up @@ -168,8 +168,6 @@ class FormGenTests extends munit.FunSuite {
Form(Seq.empty, Map.empty)
)

// TODO(kπ) Add test for WeirdGADT

checkGeneratedFormEquals(
"concatAll",
concatAll,
Expand Down Expand Up @@ -214,26 +212,26 @@ class FormGenTests extends munit.FunSuite {
"Node" -> FormElement.FieldSet(
"value",
List(
FormElement.NamedRef("left", "guinep.tests.FormGenTests$.IntTree"),
FormElement.NamedRef("left", "guinep.tests.TestsData$.IntTree"),
FormElement.NamedRef("value", "scala.Int"),
FormElement.NamedRef("right", "guinep.tests.FormGenTests$.IntTree")
FormElement.NamedRef("right", "guinep.tests.TestsData$.IntTree")
)
)
)
)
),
Map(
"scala.Int" -> FormElement.NumberInput("value"),
"guinep.tests.FormGenTests$.IntTree" -> FormElement.Dropdown(
"guinep.tests.TestsData$.IntTree" -> FormElement.Dropdown(
"value",
List(
"Leaf" -> FormElement.FieldSet("value", Nil),
"Node" -> FormElement.FieldSet(
"value",
List(
FormElement.NamedRef("left", "guinep.tests.FormGenTests$.IntTree"),
FormElement.NamedRef("left", "guinep.tests.TestsData$.IntTree"),
FormElement.NamedRef("value", "scala.Int"),
FormElement.NamedRef("right", "guinep.tests.FormGenTests$.IntTree")
FormElement.NamedRef("right", "guinep.tests.TestsData$.IntTree")
)
)
)
Expand All @@ -243,93 +241,9 @@ class FormGenTests extends munit.FunSuite {
)
)

// TODO(kπ) Add test for WeirdGADT

// TODO(kπ) Add test for isInTreeExt

// TODO(kπ) Add test for addManyParamLists
}

object FormGenTests {
def upperCaseText(text: String): String =
text.toUpperCase

def add(a: Int, b: Int) =
a + b

def concat(a: String, b: String) =
a + b

def giveALongText(b: Boolean): String =
if b then "XXXXXXXXXXXXXXXXXXXXXX" else "-"

case class Add(a: Int, b: Int)

def addObj(add: Add) =
add.a + add.b

def greetMaybeName(maybeName: Option[String]): String =
maybeName.fold("Hello!")(name => s"Hello, $name!")

enum Language:
case English, Polish

def greetInLanguage(name: String, language: Language): String =
language match
case Language.English => s"Hello, $name!"
case Language.Polish => s"Cześć, $name!"

sealed trait MaybeString
case class JustString(value: String) extends MaybeString
case object NoString extends MaybeString

def nameWithPossiblePrefix(name: String, maybePrefix: MaybeString): String =
maybePrefix match
case JustString(value) => s"$value $name"
case NoString => name

enum MaybeString1:
case JustString(value: String)
case NoString

def nameWithPossiblePrefix1(name: String, maybePrefix: MaybeString1): String =
maybePrefix match
case MaybeString1.JustString(value) => s"$value $name"
case MaybeString1.NoString => name

def roll20: Int =
scala.util.Random.nextInt(20) + 1

def roll6(): Int =
scala.util.Random.nextInt(6) + 1

sealed trait WeirdGADT[+A]
case class IntValue(value: Int) extends WeirdGADT[Int]
case class SomeValue[+A](value: A) extends WeirdGADT[A]
case class SomeOtherValue[+A, +B](value: A, value2: B) extends WeirdGADT[A]

// This fails on unknown type params
def printsWeirdGADT(g: WeirdGADT[String]): String = g match
case SomeValue(value) => s"SomeValue($value)"
case SomeOtherValue(value, value2) => s"SomeOtherValue($value, $value2)"

def concatAll(elems: List[String]): String =
elems.mkString

enum IntTree:
case Leaf
case Node(left: IntTree, value: Int, right: IntTree)

def isInTree(elem: Int, tree: IntTree): Boolean = tree match
case IntTree.Leaf => false
case IntTree.Node(left, value, right) =>
value == elem || isInTree(elem, left) || isInTree(elem, right)

// Can't be handled right now
extension (elem: Int)
def isInTreeExt(tree: IntTree): Boolean = tree match
case IntTree.Leaf => false
case IntTree.Node(left, value, right) =>
value == elem || elem.isInTreeExt(left) || elem.isInTreeExt(right)

def addManyParamLists(a: Int)(b: Int): Int =
a + b
}
180 changes: 180 additions & 0 deletions guinep/src/test/scala/rungentests.scala
Original file line number Diff line number Diff line change
@@ -0,0 +1,180 @@
package guinep
package tests

import guinep.model.*

class RunGenTests extends munit.FunSuite {
import TestsData.*

inline def checkGeneratedRunResultSatisfies(name: String, inline f: Any, args: List[Any], assertResult: Any => Unit): Unit =
test(s"generate run for function $name applied to ${args} is correct") {
val infos = macros.funInfos(f)
assert(infos.length == 1, s"Expected 1 run info, got: $infos")
val info = infos.head
assertResult(info.run(args))
}

inline def checkGeneratedRunResultEquals(name: String, inline f: Any, args: List[Any], expected: String): Unit =
checkGeneratedRunResultSatisfies(name, f, args, result => assertEquals(result, expected))

checkGeneratedRunResultEquals(
"upperCaseText",
upperCaseText,
List("hello"),
"HELLO"
)

checkGeneratedRunResultEquals(
"add",
add,
List(1, 2),
"3"
)

checkGeneratedRunResultEquals(
"concat",
concat,
List("hello", "world"),
"helloworld"
)

checkGeneratedRunResultEquals(
"giveALongText",
giveALongText,
List(true),
"XXXXXXXXXXXXXXXXXXXXXX"
)

checkGeneratedRunResultEquals(
"giveALongText",
giveALongText,
List(false),
"-"
)

checkGeneratedRunResultEquals(
"addObj",
addObj,
List(Map("a" -> 1, "b" -> 2)),
"3"
)

checkGeneratedRunResultEquals(
"greetMaybeName",
greetMaybeName,
List(Map("name" -> "Some", "value" -> Map("value" -> "John"))),
"Hello, John!"
)

checkGeneratedRunResultEquals(
"greetMaybeName",
greetMaybeName,
List(Map("name" -> "None", "value" -> Map.empty)),
"Hello!"
)

checkGeneratedRunResultEquals(
"greetInLanguage",
greetInLanguage,
List("John", Map("name" -> "English", "value" -> Map.empty)),
"Hello, John!"
)

checkGeneratedRunResultEquals(
"greetInLanguage",
greetInLanguage,
List("John", Map("name" -> "Polish", "value" -> Map.empty)),
"Cześć, John!"
)

checkGeneratedRunResultEquals(
"nameWithPossiblePrefix",
nameWithPossiblePrefix,
List("John", Map("name" -> "JustString", "value" -> Map("value" -> "Mr."))),
"Mr. John"
)

checkGeneratedRunResultEquals(
"nameWithPossiblePrefix",
nameWithPossiblePrefix,
List("John", Map("name" -> "NoString", "value" -> Map.empty)),
"John"
)

checkGeneratedRunResultEquals(
"nameWithPossiblePrefix1",
nameWithPossiblePrefix1,
List("John", Map("name" -> "JustString", "value" -> Map("value" -> "Mr."))),
"Mr. John"
)

checkGeneratedRunResultEquals(
"nameWithPossiblePrefix1",
nameWithPossiblePrefix1,
List("John", Map("name" -> "NoString", "value" -> Map.empty)),
"John"
)

checkGeneratedRunResultSatisfies(
"roll20",
roll20,
List.empty,
{
case resultString: String =>
val result = resultString.toInt
assert(result >= 1 && result <= 20)
}
)

checkGeneratedRunResultSatisfies(
"roll6",
roll6(),
List.empty,
{
case resultString: String =>
val result = resultString.toInt
assert(result >= 1 && result <= 6)
}
)

checkGeneratedRunResultEquals(
"concatAll",
concatAll,
List(Map("name" -> "::", "value" -> Map("head" -> "hello", "next" -> Map("name" -> "::", "value" -> Map("head" -> "world", "next" -> Map("name" -> "Nil", "value" -> Map.empty)))))),
"helloworld"
)

checkGeneratedRunResultEquals(
"concatAll",
concatAll,
List(Map("name" -> "Nil", "value" -> Map.empty)),
""
)

checkGeneratedRunResultEquals(
"concatAll",
concatAll,
List(Map("name" -> "::", "value" -> Map("head" -> "hello", "next" -> Map("name" -> "Nil", "value" -> Map.empty)))),
"hello"
)

checkGeneratedRunResultEquals(
"isInTree",
isInTree,
List(1, Map("name" -> "Node", "value" -> Map("left" -> Map("name" -> "Leaf", "value" -> Map.empty), "value" -> 1, "right" -> Map("name" -> "Leaf", "value" -> Map.empty)))),
"true"
)

checkGeneratedRunResultEquals(
"isInTree",
isInTree,
List(1, Map("name" -> "Leaf", "value" -> Map.empty)),
"false"
)

// TODO(kπ) Add test for WeirdGADT

// TODO(kπ) Add test for isInTreeExt

// TODO(kπ) Add test for addManyParamLists
}
Loading

0 comments on commit d35fda7

Please sign in to comment.