diff --git a/guinep/src/test/scala/formgentests.scala b/guinep/src/test/scala/formgentests.scala
index 3bf7a1a..9b8c19c 100644
--- a/guinep/src/test/scala/formgentests.scala
+++ b/guinep/src/test/scala/formgentests.scala
@@ -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") {
@@ -168,8 +168,6 @@ class FormGenTests extends munit.FunSuite {
     Form(Seq.empty, Map.empty)
   )
 
-  // TODO(kπ) Add test for WeirdGADT
-
   checkGeneratedFormEquals(
     "concatAll",
     concatAll,
@@ -214,9 +212,9 @@ 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")
               )
             )
           )
@@ -224,16 +222,16 @@ class FormGenTests extends munit.FunSuite {
       ),
       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")
               )
             )
           )
@@ -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
-}
diff --git a/guinep/src/test/scala/rungentests.scala b/guinep/src/test/scala/rungentests.scala
new file mode 100644
index 0000000..b05ead5
--- /dev/null
+++ b/guinep/src/test/scala/rungentests.scala
@@ -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
+}
diff --git a/guinep/src/test/scala/testsdata.scala b/guinep/src/test/scala/testsdata.scala
new file mode 100644
index 0000000..9681251
--- /dev/null
+++ b/guinep/src/test/scala/testsdata.scala
@@ -0,0 +1,87 @@
+package guinep.tests
+
+object TestsData {
+  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]
+
+  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)
+
+  // 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)"
+
+  // 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
+}