- when Selectors supplied include only TestSelectors and TestWildcardSelectors, filter properties to run by matching their names against the Selectors;

- match a property by both its short and full name;
- added a test that actually runs ScalaCheck via the `SBT Test Interface` and demonstrates the (now correct) treatment of the `Selector`s;
- test also demonstrates two unfixable infidelities in the treatment of the nested properties;
- thankfully, ScalaCheck's implementation of `sbt.testing.Framework` is, unlike in some other test frameworks, shared between the platforms (JVM, Scala.js, Scala Native), so the fixes do not have to be replicated for each platform, but:
- the test needs to supply a `testClassLoader: ClassLoader` parameter when calling `sbt.testing.Framework.runner()`; on platforms other than JVM, `getClass.getClassLoader` is not available, so `Platform.getClassLoader: ClassLoader` method was added to every `Platform`; on platforms other than the JVM, it returns `null`, which is fine since on those platforms `sbt.testing.Framework.runner()` ignores the `testClassLoader` parameter anyway.

fixes #1105

Author: dubinsky

core/js/src/main/scala/org/scalacheck/Platform.scala

@@ -46,4 +46,6 @@ private[scalacheck] object Platform {
   }
 
   type EnableReflectiveInstantiation = scala.scalajs.reflect.annotation.EnableReflectiveInstantiation
+
+  def getClassLoader: ClassLoader = null
 }

core/jvm/src/main/scala/org/scalacheck/Platform.scala

@@ -73,4 +73,6 @@ private[scalacheck] object Platform {
     Class.forName(name + "$", true, loader).getField("MODULE$").get(null)
 
   class EnableReflectiveInstantiation extends scala.annotation.Annotation
+
+  def getClassLoader: ClassLoader = getClass.getClassLoader
 }

core/native/src/main/scala/org/scalacheck/Platform.scala

@@ -46,4 +46,6 @@ private[scalacheck] object Platform {
   }
 
   type EnableReflectiveInstantiation = scala.scalanative.reflect.annotation.EnableReflectiveInstantiation
+
+  def getClassLoader: ClassLoader = null
 }

core/shared/src/main/scala/org/scalacheck/ScalaCheckFramework.scala

@@ -92,8 +92,24 @@ private abstract class ScalaCheckRunner extends Runner {
   }
 
   def rootTask(td: TaskDef): BaseTask = new BaseTask(td) {
-    def execute(handler: EventHandler, loggers: Array[Logger]): Array[Task] =
-      props.map(_._1).toSet.toArray map { name =>
+    def execute(handler: EventHandler, loggers: Array[Logger]): Array[Task] = {
+      val isTestsOnly: Boolean = td.selectors().forall(selector =>
+        selector.isInstanceOf[TestSelector] ||
+        selector.isInstanceOf[TestWildcardSelector]
+      )
+
+      // Both the name used to define the property (`propName`)
+      // and the name reported when it runs (`fullName`)
+      // work when asking for a property by name or when using wildcards.
+
+      val prefix: String = properties.map(properties => s"${properties.name}.").getOrElse("")
+      def isIncluded(name: String): Boolean = !isTestsOnly || td.selectors().exists {
+        case s: TestSelector => name == s.testName() || name.stripPrefix(prefix) == s.testName()
+        case s: TestWildcardSelector => name.contains(s.testWildcard())
+        case _ => false
+      }
+
+      props.map(_._1).toSet.filter(isIncluded).toArray map { name =>
         checkPropTask(
           new TaskDef(
             td.fullyQualifiedName(),
@@ -102,6 +118,7 @@ private abstract class ScalaCheckRunner extends Runner {
             Array(new TestSelector(name))),
           single = true)
       }
+    }
   }
 
   def checkPropTask(taskDef: TaskDef, single: Boolean): BaseTask = new BaseTask(taskDef) { self =>

core/shared/src/test/scala/org/scalacheck/SbtSpecification.scala

@@ -0,0 +1,65 @@
+package org.scalacheck
+
+import sbt.testing.{Event, EventHandler, Framework, Selector, SuiteSelector, Task, TaskDef, TestSelector, TestWildcardSelector}
+
+object SbtFixture extends Properties("SbtFixture") {
+  property("success") = Prop.passed
+}
+
+object SbtNestingFixture extends Properties("SbtNestingFixture") {
+  include(SbtFixture)
+}
+
+object SbtSpecification extends Properties("Sbt") {
+  property("suite") = run(Array(new SuiteSelector)) == List("SbtFixture.success")
+
+  property("exact"     ) = run(Array(new TestSelector("success"           ))) == List("SbtFixture.success")
+  property("exactFull" ) = run(Array(new TestSelector("SbtFixture.success"))) == List("SbtFixture.success")
+  property("exactMissing") = run(Array(new TestSelector("nonexistent"))) == List.empty
+
+  property("wildcard"    ) = run(Array(new TestWildcardSelector("succ"      ))) == List("SbtFixture.success")
+  property("wildcardFull") = run(Array(new TestWildcardSelector("xture.succ"))) == List("SbtFixture.success")
+  property("wildcardMissing") = run(Array(new TestWildcardSelector("prev"))) == List.empty
+
+  // Since ScalaCheck does not keep track what class/object a property belongs to,
+  // the following two issues concerning nested properties can not be fixed:
+  //
+  // When `explicitlySpecified = true`, properties from objects other than the one being run
+  // should *not* run (and the outcome should be `List.empty`) - but they do.
+  //
+  // When a property from an object other than the one being run *does* run,
+  // its status should be reported with a `NestedTestSelector`
+  // where `suiteId` names the object that the property belongs to -
+  // but it is reported with a `TestSelector`.
+
+  property("nestedShouldRun") = run(
+    Array(new SuiteSelector),
+    fullyQualifiedName = "org.scalacheck.SbtNestingFixture",
+    explicitlySpecified = false
+  ) == List("SbtNestingFixture.SbtFixture.success")
+
+  property("nestedShouldNotRun") = run(
+    Array(new SuiteSelector),
+    fullyQualifiedName = "org.scalacheck.SbtNestingFixture",
+    explicitlySpecified = true
+  ) == List("SbtNestingFixture.SbtFixture.success")
+
+  // run using SBT Test Interface
+  def run(
+    selectors: Array[Selector],
+    fullyQualifiedName: String = "org.scalacheck.SbtFixture",
+    explicitlySpecified: Boolean = false
+  ): List[String] = {
+    val framework: Framework = new ScalaCheckFramework
+    var ran: List[String] = List.empty
+    val eventHandler: EventHandler = (event: Event) => ran = ran.appended(event.selector().asInstanceOf[TestSelector].testName())
+    def execute(tasks: Array[Task]): Unit = tasks.foreach(task => execute(task.execute(eventHandler, Array.empty)))
+    execute(framework.runner(Array.empty, Array.empty, Platform.getClassLoader).tasks(Array(new TaskDef(
+      fullyQualifiedName,
+      framework.fingerprints()(2), // object ... extends org.scalacheck.Properties
+      explicitlySpecified,
+      selectors
+    ))))
+    ran
+  }
+}