Question

在我的单元测试中，我需要生成各种事件，这些事件都从一个抽象的Event类继承，但是以不同的方式创建。例如，事件A和B具有以下签名：

def makeEventA(a: Int, b: String): EventA

def makeEventB(p: String, q: Long, r: Long): EventB

两个事件的核心逻辑是相同的，并且在Event的任何子类上定义，所以我想创建行为函数并重新使用它们。为此我想创建一个'Maker'特征，我可以从中制作每个单独的事件并在单元测试中使用结果：

trait EventMaker {
  def make[T <: Event](...): T
}

class EventAMaker extends EventMaker {
  override def make[EventA](...) = /* custom implementation */
}

// similar for EventBMaker

我的想法是让单元测试放在合适的类中，并根据调用适当的make方法。我想通过ScalaTest对ScalaCheck的内置支持来改变参数，这样我就不必对所有值和不同事件进行硬编码，并且基本上复制粘贴相同的代码（参数列表除外）。

我正在努力的是make的签名。它应该为特定类采用适当的参数，它们的数量，类型和名称都不同。是我想要实现甚至可行/明智的，有更好的方法，或者我该如何进行？

我想到的替代方案是匹配各种事件并调用相应的make方法（工厂设计模式），但这会导致同样的问题：

def make[T <: Event](eventType: T, ...): T = eventType match {
  case EventA => new EventMakerA(...)
  case EventB => new EventMakerB(...)
  case _ => ...
}

另一种选择是对所有参数使用Option，默认值为None，以便签名匹配。然而，这似乎是浪费，并没有完全提高易读性。

Answer 1

我相信，最好的办法是将参数打包成不透明的Tuple，然后动态或静态地检查，如果元组与Event所需的参数匹配。

假设以下设置：

import scala.reflect._

sealed trait Event

case class EventA(a: Int, b: String) extends Event
object EventA {
  // this val is needed only for the dynamic checking approach
  final val tag = classTag[EventA]
}

case class EventB(p: String, q: Long, r: Long) extends Event
object EventB {
  // this val is needed only for the dynamic checking approach
  final val tag = classTag[EventB]
}

当您动态检查时，您只需匹配参数，并检查它们是否在具有正确长度和正确元素类型的元组中。这不是类型安全的，并且如果事件参数具有带类型参数的类型（例如，ClassCastException或l: List[Int]），则可以在运行时抛出t: (Int, Double)，因此类型擦除会启动。< / p>

代码可以用不同的方式组织：

def make[T <: Event, Args](obj: Class[T], args: Args)(implicit tag: ClassTag[T]): T = ((tag, args) match {
  case (EventA.tag, (a: Int, b: String)) => EventA(a, b)
  case (EventB.tag, (p: String, q: Long, r: Long)) => EventB(p, q, r)
  case (otherTag, otherArgs) => sys.error("wrong args for tag")
}).asInstanceOf[T]

scala> make(classOf[EventA], (10, "foo"))
res4: EventA = EventA(10,foo)

scala> make(classOf[EventB], ("bar", 10L, 20L))
res5: EventB = EventB(bar,10,20)

或者您可以将其提取到一个类中，以便能够将精确的Event类型作为类型参数传递：

class EventMaker[T <: Event] {
  def apply[Args](args: Args)(implicit tag: ClassTag[T]): T = ((tag, args) match {
    case (EventA.tag, (a: Int, b: String)) => EventA(a, b)
    case (EventB.tag, (p: String, q: Long, r: Long)) => EventB(p, q, r)
    case (otherTag, otherArgs) => sys.error("wrong args for tag")
  }).asInstanceOf[T]
}
def make2[T <: Event] = new EventMaker[T]

scala> make2[EventA](10, "foo")
res6: EventA = EventA(10,foo)

scala> make2[EventB]("bar", 10L, 20L)
res7: EventB = EventB(bar,10,20)

您还可以使用shapeless库（或者使用手写宏）静态检查参数。如果提供的参数与case类所需的参数不匹配，则会导致编译错误。此外，如果单个事件由案例类表示，但这也适用于shapeless.ops.function.FnToProduct

支持某些函数，则效果最佳

import shapeless._

class EventMaker3[T <: Event] {
  def apply[Args, H <: HList, H0 <: HList](args: Args)(implicit
    genObj: Generic.Aux[T, H],      // conversion between HList and case class
    genArgs: Generic.Aux[Args, H0], // conversion between HList and arguments tuple
    ev: H0 =:= H                    // assert that HList representations of the case class 
                                    // and provided arguments are the same
  ): T = genObj.from(genArgs.to(args))
}
def make3[T <: Event] = new EventMaker3[T]

scala> make3[EventA](10, "foo")
res8: EventA = EventA(10,foo)

scala> make3[EventB]("bar", 10L, 20L)
res9: EventB = EventB(bar,10,20)

scala> make3[EventA](1, 2)
<console>:21: error: Cannot prove that H0 =:= H.
       make3[EventA](1, 2)
                    ^

在Scala中创建需要不同构造函数参数的子类型的通用方法

1 个答案: