test: Add stupid PBT

ysthakur · ysthakur · commit 6fdd6b0b6223 · 2024-11-19T04:07:00.000-05:00
diff --git a/src/main/scala/fred/AST.scala b/src/main/scala/fred/AST.scala
@@ -1,12 +1,20 @@
 package fred
 
-case class Span(start: Int, end: Int)
+case class Span(start: Int, end: Int) {
+  override def toString =
+    if (start == -1 && end == -1) "(:)"
+    else s"($start:$end)"
+}
 
 object Span {
-  def synthetic = Span(-1, -1)
+
+  /** A dummy span to use for generated code */
+  def synth = Span(-1, -1)
 }
 
-case class Spanned[T](value: T, span: Span)
+case class Spanned[T](value: T, span: Span) {
+  override def toString: String = value.toString
+}
 
 case class ParsedFile(typeDefs: List[TypeDef], fns: List[FnDef])
 
@@ -90,8 +98,12 @@ enum BinOp(val text: String) {
   case Seq extends BinOp(";")
 }
 
-case class BinExpr(lhs: Expr, op: Spanned[BinOp], rhs: Expr, typ: Option[Type])
-    extends Expr {
+case class BinExpr(
+    lhs: Expr,
+    op: Spanned[BinOp],
+    rhs: Expr,
+    typ: Option[Type] = None
+) extends Expr {
   override def span = Span(lhs.span.start, rhs.span.end)
 }
 
@@ -105,8 +117,7 @@ case class IfExpr(cond: Expr, thenBody: Expr, elseBody: Expr, span: Span)
   override def typ = None
 }
 
-/** An expression for setting a field on a variable
-  */
+/** An expression for setting a field on a variable */
 case class SetFieldExpr(
     lhsObj: Spanned[String],
     lhsField: Spanned[String],
@@ -116,8 +127,7 @@ case class SetFieldExpr(
   override def typ = None
 }
 
-/** What a variable reference can resolve to
-  */
+/** What a variable reference can resolve to */
 enum VarDef {
   case Let(expr: LetExpr, typ: Type)
   case Param(param: fred.Param, typ: Type)
diff --git a/src/main/scala/fred/Type.scala b/src/main/scala/fred/Type.scala
@@ -17,7 +17,7 @@ enum BuiltinType extends Type {
     }
   }
 
-  override def span = Span.synthetic
+  override def span = Span.synth
 }
 
 case class TypeDef(
diff --git a/src/test/scala/fred/ExecTests.scala b/src/test/scala/fred/ExecTests.scala
@@ -1,21 +1,42 @@
 package fred
 
 import org.scalatest.funsuite.AnyFunSuite
+import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
 import snapshot4s.scalatest.SnapshotAssertions
 import snapshot4s.generated.snapshotConfig
 
 import scala.sys.process.*
 import java.nio.file.Paths
+import java.nio.file.Files
+import java.nio.file.Path
+
+class ExecTests
+    extends AnyFunSuite,
+      SnapshotAssertions,
+      ScalaCheckPropertyChecks {
+  def valgrindCheck(code: String, outFile: String)(expected: String): Unit = {
+    valgrindCheck(Parser.parse(code), outFile, Some(expected), snapshot = true)
+  }
 
-class ExecTests extends AnyFunSuite with SnapshotAssertions {
-  def valgrindCheck(code: String, outFile: String)(expected: String) = {
-    val parsedFile = Parser.parse(code)
+  def valgrindCheck(
+      parsedFile: ParsedFile,
+      outFile: String,
+      expected: Option[String],
+      snapshot: Boolean
+  ): Unit = {
     given typer: Typer = Typer.resolveAllTypes(parsedFile)
     val generatedC = Translator.toC(parsedFile)
 
-    assertFileSnapshot(generatedC, s"exec/$outFile")
+    val outPath =
+      if (snapshot) {
+        assertFileSnapshot(generatedC, s"exec/$outFile")
+        s"src/test/resources/snapshot/exec/$outFile"
+      } else {
+        Files.write(Path.of(outFile), generatedC.getBytes())
+        outFile
+      }
 
-    s"gcc -g -I ${Compiler.includesFolder()} src/test/resources/snapshot/exec/$outFile".!!
+    s"gcc -g -I ${Compiler.includesFolder()} $outPath".!!
 
     val stderrBuf = StringBuilder()
     val stdout =
@@ -29,7 +50,11 @@ class ExecTests extends AnyFunSuite with SnapshotAssertions {
           throw RuntimeException(stderrBuf.toString, e)
       }
     val valgrindOut = stderrBuf.toString
-    assert(stdout.trim() === expected.trim(), valgrindOut)
+    expected match {
+      case Some(expected) =>
+        assert(stdout.trim() === expected.trim(), valgrindOut)
+      case None =>
+    }
     assert(valgrindOut.contains("ERROR SUMMARY: 0 errors"), valgrindOut)
   }
 
@@ -125,4 +150,16 @@ class ExecTests extends AnyFunSuite with SnapshotAssertions {
 
     valgrindCheck(code, "contrived-needs-sorting.c")("")
   }
+
+  test("asdf") {
+    assert(GenerateTypes.toTypes(List.empty) == List.empty)
+  }
+
+  test("Simple generated programs") {
+    given PropertyCheckConfiguration =
+      PropertyCheckConfiguration(minSize = 1, sizeRange = 5)
+    forAll(GenerateTypes.genTypesAux().flatMap(GenerateTypes.genCode)) {
+      parsedFile => valgrindCheck(parsedFile, "foo.c", None, snapshot = false)
+    }
+  }
 }
diff --git a/src/test/scala/fred/GenerateTypes.scala b/src/test/scala/fred/GenerateTypes.scala
@@ -1,11 +1,14 @@
 package fred
 
 import scala.collection.mutable
+import scala.jdk.CollectionConverters.*
 
 import org.scalacheck.Gen
 
 object GenerateTypes {
-  case class GeneratedType(refs: List[Int])
+  private val SomeField = "value"
+
+  case class GenTypeAux(refs: List[Int])
 
   /** Generate a bunch of types. Each type is its own strongly-connected
     * component. The returned list is sorted backwards (types that come later in
@@ -17,69 +20,130 @@ object GenerateTypes {
     *
     * All references are mutable, for testing cycles.
     */
-  def genTypes(): Gen[List[GeneratedType]] = {
+  def genTypesAux(): Gen[List[GenTypeAux]] = {
     Gen.choose(1, 40).flatMap { numSccs =>
       Gen.sequence(0.until(numSccs).map { i =>
-        Gen.listOf(Gen.chooseNum(0, i)).map(GeneratedType(_))
+        Gen.listOf(Gen.chooseNum(0, i)).map(GenTypeAux(_))
       })
     }
   }
 
-  def generateAst(typeAuxes: List[GeneratedType]): ParsedFile = {
-    def nameFor(ind: Int) = s"T$ind"
+  private def nameForType(ind: Int) = s"T$ind"
+
+  /** Name for the optional type corresponding to the type at index `ind` */
+  private def nameForOptType(ind: Int) = s"OptT$ind"
+  private def someCtorName(ind: Int) = s"Some$ind"
+  private def noneCtorName(ind: Int) = s"None$ind"
 
-    /** Name for the optional type corresponding to the type at index `ind` */
-    def nameForOpt(ind: Int) = s"OptT$ind"
+  private def nameForField(ind: Int) = s"f$ind"
 
-    val types = typeAuxes.zipWithIndex.map { case (GeneratedType(refs), i) =>
-      val typeName = Spanned(nameFor(i), Span.synthetic)
+  def toTypes(typeAuxes: List[GenTypeAux]): List[TypeDef] = {
+    val types = typeAuxes.zipWithIndex.map { case (GenTypeAux(refs), i) =>
+      val typeName = Spanned(nameForType(i), Span.synth)
       TypeDef(
         typeName,
         List(
           EnumCase(
             typeName,
             refs.zipWithIndex.map { (typeInd, fieldInd) =>
               val fieldType =
-                if (i == typeInd) nameForOpt(typeInd) else nameFor(typeInd)
+                if (i == typeInd) nameForOptType(typeInd)
+                else nameForType(typeInd)
               FieldDef(
                 true,
-                Spanned(s"f$fieldInd", Span.synthetic),
-                TypeRef(fieldType, Span.synthetic),
-                Span.synthetic
+                Spanned(nameForField(fieldInd), Span.synth),
+                TypeRef(fieldType, Span.synth),
+                Span.synth
               )
             },
-            Span.synthetic
+            Span.synth
           )
         ),
-        Span.synthetic
+        Span.synth
       )
     }
     // Generate optional types for self-referential types
     val optTypes = typeAuxes.zipWithIndex
-      .filter { case (GeneratedType(refs), i) =>
+      .filter { case (GenTypeAux(refs), i) =>
         refs.contains(i)
       }
       .map { (_, i) =>
-        val name = Spanned(nameForOpt(i), Span.synthetic)
         TypeDef(
-          name,
+          Spanned(nameForOptType(i), Span.synth),
           List(
             EnumCase(
-              name,
+              Spanned(someCtorName(i), Span.synth),
               List(
                 FieldDef(
                   false,
-                  Spanned("value", Span.synthetic),
-                  TypeRef(nameFor(i), Span.synthetic),
-                  Span.synthetic
+                  Spanned(SomeField, Span.synth),
+                  TypeRef(nameForType(i), Span.synth),
+                  Span.synth
                 )
               ),
-              Span.synthetic
+              Span.synth
+            ),
+            EnumCase(
+              Spanned(noneCtorName(i), Span.synth),
+              Nil,
+              Span.synth
             )
           ),
-          Span.synthetic
+          Span.synth
+        )
+      }
+    types ++ optTypes
+  }
+
+  def genCode(typeAuxes: List[GenTypeAux]): Gen[ParsedFile] = {
+    val types = toTypes(typeAuxes)
+
+    def genExpr(typeInd: Int): Gen[Expr] = {
+      val GenTypeAux(refs) = typeAuxes(typeInd)
+      val fieldGens = refs.zipWithIndex.map { case (fieldTypeInd, fieldInd) =>
+        val fieldName = Spanned(nameForField(fieldInd), Span.synth)
+        val value =
+          if (fieldTypeInd < typeInd) {
+            genExpr(fieldTypeInd)
+          } else {
+            Gen.const(
+              CtorCall(
+                Spanned(noneCtorName(typeInd), Span.synth),
+                Nil,
+                Span.synth
+              )
+            )
+          }
+        value.map((fieldName, _))
+      }
+      // TODO Why in the world is this an ArrayList?
+      Gen.sequence(fieldGens).map { fields =>
+        CtorCall(
+          Spanned(nameForType(typeInd), Span.synth),
+          fields.asScala.toList,
+          Span.synth
         )
       }
-    ParsedFile(types ++ optTypes, Nil)
+    }
+
+    genExpr(typeAuxes.length - 1).map { expr =>
+      ParsedFile(
+        types,
+        List(
+          FnDef(
+            Spanned("main", Span.synth),
+            Nil,
+            TypeRef("int", Span.synth),
+            LetExpr(
+              Spanned("ignored", Span.synth),
+              expr,
+              IntLiteral(0, Span.synth),
+              Span.synth
+            ),
+            Span.synth
+          )
+        )
+      )
+    }
   }
 }
diff --git a/src/test/scala/fred/SCCTests.scala b/src/test/scala/fred/SCCTests.scala
@@ -14,21 +14,21 @@ class SCCTests
   def createFile(graph: Map[String, Set[(Boolean, String)]]): ParsedFile = {
     ParsedFile(
       graph.map { (name, neighbors) =>
-        val spannedName = Spanned(name, Span.synthetic)
+        val spannedName = Spanned(name, Span.synth)
         val fields = graph(name).toList.map { (mutable, neighborName) =>
           FieldDef(
             mutable,
-            Spanned(s"field$neighborName", Span.synthetic),
-            TypeRef(neighborName, Span.synthetic),
-            Span.synthetic
+            Spanned(s"field$neighborName", Span.synth),
+            TypeRef(neighborName, Span.synth),
+            Span.synth
           )
         }
         TypeDef(
           spannedName,
           List(
-            EnumCase(spannedName, fields, Span.synthetic)
+            EnumCase(spannedName, fields, Span.synth)
           ),
-          Span.synthetic
+          Span.synth
         )
       }.toList,
       Nil
@@ -118,8 +118,8 @@ class SCCTests
   }
 
   test("Ensure strongly-connected components valid using Gen") {
-    forAll(GenerateTypes.genTypes()) { typesAux =>
-      val file = GenerateTypes.generateAst(typesAux)
+    forAll(GenerateTypes.genTypesAux()) { typesAux =>
+      val file = ParsedFile(GenerateTypes.toTypes(typesAux), Nil)
       val cycles = Cycles.fromFile(file)
 
       assert(cycles.sccs.size === typesAux.size)

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ enum BuiltinType extends Type {`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`- override def span = Span.synthetic`
	`20`	`+ override def span = Span.synth`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`case class TypeDef(`