stats

Author: SaadAissa

src/test/scala/ch/epfl/scala/decoder/BinaryDecoderStats.scala

@@ -13,14 +13,16 @@ class BinaryDecoderStats extends BinaryDecoderSuite:
     val decoder = initDecoder("org.scala-lang", "scala3-compiler_3", "3.3.1")
     decoder.assertDecodeAll(
       expectedClasses = ExpectedCount(4426),
-      expectedMethods = ExpectedCount(68421, ambiguous = 25, notFound = 33)
+      expectedMethods = ExpectedCount(68421, ambiguous = 25, notFound = 33),
+      expectedFields = ExpectedCount(12548, ambiguous = 27, notFound = 1)
     )
 
   test("scala3-compiler:3.0.2"):
     val decoder = initDecoder("org.scala-lang", "scala3-compiler_3", "3.0.2")
     decoder.assertDecodeAll(
       expectedClasses = ExpectedCount(3859, notFound = 3),
-      expectedMethods = ExpectedCount(60762, ambiguous = 24, notFound = 163)
+      expectedMethods = ExpectedCount(60762, ambiguous = 24, notFound = 163),
+      expectedFields = ExpectedCount(10670, ambiguous = 23, notFound = 6)
     )
 
   test("io.github.vigoo:zio-aws-ec2_3:4.0.5 - slow".ignore):
@@ -32,15 +34,23 @@ class BinaryDecoderStats extends BinaryDecoderSuite:
 
   test("org.tpolecat:doobie-h2_3:0.13.4"):
     val decoder = initDecoder("org.tpolecat", "doobie-h2_3", "0.13.4")
-    decoder.assertDecodeAll(ExpectedCount(10), ExpectedCount(218))
+    decoder.assertDecodeAll(
+      expectedClasses = ExpectedCount(10),
+      expectedMethods = ExpectedCount(218),
+      expectedFields = ExpectedCount(45)
+    )
 
   test("net.zygfryd:jackshaft_3:0.2.2".ignore):
     val decoder = initDecoder("net.zygfryd", "jackshaft_3", "0.2.2", FetchOptions(keepProvided = true))
     decoder.assertDecodeAll(ExpectedCount(49, notFound = 1), ExpectedCount(454, notFound = 1))
 
   test("company.jap:fields-core_3:0.4.16"):
     val decoder = initDecoder("company.jap", "fields-core_3", "0.4.16", FetchOptions(keepOptional = true))
-    decoder.assertDecodeAll(ExpectedCount(245), ExpectedCount(2755, notFound = 92))
+    decoder.assertDecodeAll(
+      expectedClasses = ExpectedCount(245),
+      expectedMethods = ExpectedCount(2755, notFound = 92),
+      expectedFields = ExpectedCount(298)
+    )
 
   test("org.clulab:processors-main_3:8.5.3"):
     assume(!isCI)
@@ -53,7 +63,11 @@ class BinaryDecoderStats extends BinaryDecoderSuite:
 
   test("com.github.simy4.xpath:xpath-to-xml-scala_3:2.3.7"):
     val decoder = initDecoder("com.github.simy4.xpath", "xpath-to-xml-scala_3", "2.3.7")
-    decoder.assertDecodeAll(ExpectedCount(27), ExpectedCount(174, notFound = 2))
+    decoder.assertDecodeAll(
+      ExpectedCount(27),
+      ExpectedCount(174, notFound = 2),
+      expectedFields = ExpectedCount(20, ambiguous = 4)
+    )
 
   test("com.zengularity:benji-google_3:2.2.1".ignore):
     val fetchOptions = FetchOptions(
@@ -81,35 +95,49 @@ class BinaryDecoderStats extends BinaryDecoderSuite:
     val decoder = initDecoder("dev.zio", "zio-interop-cats_3", "23.1.0.0")(using ThrowOrWarn.ignore)
     decoder.assertDecodeAll(
       ExpectedCount(149, notFound = 9),
-      ExpectedCount(3546, notFound = 59)
+      ExpectedCount(3546, notFound = 59),
+      expectedFields = ExpectedCount(144, notFound = 2)
     )
 
   test("com.evolution:scache_3:5.1.2"):
     val fetchOptions = FetchOptions(
       repositories = Seq(MavenRepository("https://evolution.jfrog.io/artifactory/public"))
     )
     val decoder = initDecoder("com.evolution", "scache_3", "5.1.2", fetchOptions)
-    decoder.assertDecodeAll(ExpectedCount(105), ExpectedCount(1509))
+    decoder.assertDecodeAll(
+      ExpectedCount(105),
+      ExpectedCount(1509),
+      expectedFields = ExpectedCount(161)
+    )
 
   test("com.github.j5ik2o:docker-controller-scala-dynamodb-local_:1.15.34"):
     val fetchOptions = FetchOptions(
       repositories = Seq(MavenRepository("https://maven.seasar.org/maven2/"))
     )
     val decoder = initDecoder("com.github.j5ik2o", "docker-controller-scala-dynamodb-local_3", "1.15.34", fetchOptions)
-    decoder.assertDecodeAll(ExpectedCount(2), ExpectedCount(37))
+    decoder.assertDecodeAll(
+      ExpectedCount(2),
+      ExpectedCount(37),
+      expectedFields = ExpectedCount(5)
+    )
 
   test("eu.ostrzyciel.jelly:jelly-grpc_3:0.5.3"):
     val fetchOptions = FetchOptions(exclusions = Seq("io.grpc" -> "grpc-core"))
     val decoder = initDecoder("eu.ostrzyciel.jelly", "jelly-grpc_3", "0.5.3", fetchOptions)
-    decoder.assertDecodeAll(ExpectedCount(24), ExpectedCount(353))
+    decoder.assertDecodeAll(
+      ExpectedCount(24),
+      ExpectedCount(353),
+      expectedFields = ExpectedCount(61)
+    )
 
   test("com.devsisters:zio-agones_3:0.1.0"):
     assume(!isJava8)
     val fetchOptions = FetchOptions(exclusions = Seq("io.grpc" -> "grpc-core"))
     val decoder = initDecoder("com.devsisters", "zio-agones_3", "0.1.0", fetchOptions)(using ThrowOrWarn.ignore)
     decoder.assertDecodeAll(
       ExpectedCount(83, notFound = 26),
-      ExpectedCount(2804, ambiguous = 2, notFound = 5)
+      ExpectedCount(2804, ambiguous = 2, notFound = 5),
+      expectedFields = ExpectedCount(258)
     )
 
   test("org.log4s:log4s_3:1.10.0".ignore):
@@ -133,8 +161,16 @@ class BinaryDecoderStats extends BinaryDecoderSuite:
 
   test("in.nvilla:regsafe_3:0.0.1: unstable TASTy version"):
     val decoder = initDecoder("in.nvilla", "regsafe_3", "0.0.1")(using ThrowOrWarn.ignore)
-    decoder.assertDecodeAll(ExpectedCount(19), ExpectedCount(158))
+    decoder.assertDecodeAll(
+      ExpectedCount(19),
+      ExpectedCount(158),
+      expectedFields = ExpectedCount(32, ambiguous = 4, notFound = 2)
+    )
 
   test("io.github.valdemargr:gql-core_3:0.3.3"):
     val decoder = initDecoder("io.github.valdemargr", "gql-core_3", "0.3.3")
-    decoder.assertDecodeAll(ExpectedCount(531), ExpectedCount(7267, ambiguous = 4, notFound = 1))
+    decoder.assertDecodeAll(
+      ExpectedCount(531),
+      ExpectedCount(7267, ambiguous = 4, notFound = 1),
+      expectedFields = ExpectedCount(851, notFound = 2)
+    )

src/test/scala/ch/epfl/scala/decoder/BinaryDecoderStatsFull.scala

@@ -31,7 +31,7 @@ class BinaryDecoderStatsFull extends BinaryDecoderSuite:
       val parts = line.split(',').map(_.drop(1).dropRight(1))
       val (org, artifact, version) = (parts(0), parts(1), parts(2))
       try
-        val (classCounter, methodCounter) = tryDecodeAll(org, artifact, version)
+        val (classCounter, methodCounter, _) = tryDecodeAll(org, artifact, version)
         classCounts += classCounter.count
         methodCounts += methodCounter.count
       catch case e => println(s"cannot decode $line")
@@ -45,15 +45,15 @@ class BinaryDecoderStatsFull extends BinaryDecoderSuite:
       .sortBy(count => -count.successPercent)
       .foreach(c => println(s"${c.name} ${c.successPercent}%"))
 
-  def tryDecodeAll(org: String, artifact: String, version: String)(using ThrowOrWarn): (Counter, Counter) =
+  def tryDecodeAll(org: String, artifact: String, version: String)(using ThrowOrWarn): (Counter, Counter, Counter) =
     val repositories =
       if org == "org.clulab" then Seq(MavenRepository("http://artifactory.cs.arizona.edu:8081/artifactory/sbt-release"))
       else if org == "com.zengularity" then
         Seq(MavenRepository("https://oss.sonatype.org/content/repositories/snapshots"))
       else if org == "com.evolution" then Seq(MavenRepository("https://evolution.jfrog.io/artifactory/public"))
       else if org == "com.github.j5ik2o" then Seq(MavenRepository("https://maven.seasar.org/maven2/"))
       else Seq.empty
-    def tryWith(keepOptional: Boolean, keepProvided: Boolean): Option[(Counter, Counter)] =
+    def tryWith(keepOptional: Boolean, keepProvided: Boolean): Option[(Counter, Counter, Counter)] =
       try
         val fetchOptions = FetchOptions(keepOptional, keepProvided, repositories)
         val decoder = initDecoder(org, artifact, version, fetchOptions)

src/test/scala/ch/epfl/scala/decoder/testutils/BinaryDecoderSuite.scala

@@ -60,6 +60,10 @@ trait BinaryDecoderSuite extends CommonFunSuite:
       val binaryField: binary.Field = loadBinaryField(className, field)
       intercept[AmbiguousException](decoder.decode(binaryField))
 
+    def assertNotFoundField(className: String, field: String)(using munit.Location): Unit =
+      val binaryField = loadBinaryField(className, field)
+      intercept[NotFoundException](decoder.decode(binaryField))
+
     def assertNotFound(declaringType: String, javaSig: String)(using munit.Location): Unit =
       val method = loadBinaryMethod(declaringType, javaSig)
       intercept[NotFoundException](decoder.decode(method))
@@ -83,34 +87,41 @@ trait BinaryDecoderSuite extends CommonFunSuite:
     def assertDecodeAll(
         expectedClasses: ExpectedCount = ExpectedCount(0),
         expectedMethods: ExpectedCount = ExpectedCount(0),
+        expectedFields: ExpectedCount = ExpectedCount(0),
         printProgress: Boolean = false
     )(using munit.Location): Unit =
-      val (classCounter, methodCounter) = decodeAll(printProgress)
+      val (classCounter, methodCounter, fieldCounter) = decodeAll(printProgress)
       if classCounter.throwables.nonEmpty then
         classCounter.printThrowables()
         classCounter.printThrowable(0)
       else if methodCounter.throwables.nonEmpty then
         methodCounter.printThrowables()
         methodCounter.printThrowable(0)
-      // methodCounter.printNotFound()
+      fieldCounter.printNotFound()
       classCounter.check(expectedClasses)
       methodCounter.check(expectedMethods)
+      fieldCounter.check(expectedFields)
 
-    def decodeAll(printProgress: Boolean = false): (Counter, Counter) =
+    def decodeAll(printProgress: Boolean = false): (Counter, Counter, Counter) =
       val classCounter = Counter(decoder.name + " classes")
       val methodCounter = Counter(decoder.name + " methods")
+      val fieldCounter = Counter(decoder.name + " fields")
       for
         binaryClass <- decoder.allClasses
         _ = if printProgress then println(s"\"${binaryClass.name}\"")
         decodedClass <- decoder.tryDecode(binaryClass, classCounter)
-        binaryMethod <- binaryClass.declaredMethods
+        binaryMethodOrField <- binaryClass.declaredMethods ++ binaryClass.declaredFields
       do
-        if printProgress then println(formatDebug(binaryMethod))
-        decoder.tryDecode(decodedClass, binaryMethod, methodCounter)
+        if printProgress then println(formatDebug(binaryMethodOrField))
+        binaryMethodOrField match
+          case m: binary.Method =>
+            decoder.tryDecode(decodedClass, m, methodCounter)
+          case f: binary.Field =>
+            decoder.tryDecode(decodedClass, f, fieldCounter)
       classCounter.printReport()
       methodCounter.printReport()
-
-      (classCounter, methodCounter)
+      fieldCounter.printReport()
+      (classCounter, methodCounter, fieldCounter)
 
     private def loadBinaryMethod(declaringType: String, method: String)(using
         munit.Location
@@ -157,10 +168,21 @@ trait BinaryDecoderSuite extends CommonFunSuite:
         case ambiguous: AmbiguousException => counter.ambiguous += ambiguous
         case ignored: IgnoredException => counter.ignored += ignored
         case e => counter.throwables += (mthd -> e)
+
+    private def tryDecode(cls: DecodedClass, field: binary.Field, counter: Counter): Unit =
+      try
+        val decoded = decoder.decode(cls, field)
+        counter.success += (field -> decoded)
+      catch
+        case notFound: NotFoundException => counter.notFound += (field -> notFound)
+        case ambiguous: AmbiguousException => counter.ambiguous += ambiguous
+        case ignored: IgnoredException => counter.ignored += ignored
+        case e => counter.throwables += (field -> e)
   end extension
 
   private def formatDebug(m: binary.Symbol): String =
     m match
+      case f: binary.Field => s"\"${f.declaringClass}\", \"${formatField(f)}\""
       case m: binary.Method => s"\"${m.declaringClass.name}\", \"${formatMethod(m)}\""
       case cls => s"\"${cls.name}\""