prove statiche per la Scala

Question

Ci sono alcune belle librerie per test in Scala ( Spec , ScalaTest , ScalaCheck ). Tuttavia, con sistema di tipi di Scala potente, parti importanti di un'API sviluppati in Scala sono espressi staticamente, di solito sotto forma di un comportamento indesiderato o non consentito impedimento dal compilatore.

Quindi, qual è il modo migliore per verificare se qualcosa è impedito dal compilatore durante la progettazione di una libreria o altro API? E 'insoddisfacente per commentare il codice che si suppone essere uncompilable e poi rimuovere il commento di verificare.

Un artificiosa List esempio test:

val list: List[Int] = List(1, 2, 3)
// should not compile
// list.add("Chicka-Chicka-Boom-Boom")

esegue una delle librerie di test esistenti gestire casi come questo? C'è un approccio che la gente uso che funziona?

L'approccio che stava prendendo in considerazione è stato quello di incorporare il codice in una stringa tripla citazione o di un elemento XML e chiamare il compilatore nel mio test. Chiamata del codice cercando qualcosa di simile:

should {
  notCompile(<code>
    val list: List[Int] = List(1, 2, 3)
    list.add("Chicka-Chicka-Boom-Boom")
  </code>)
}

In alternativa, qualcosa sulla falsariga di un aspettarsi -tipo script chiamato sul interprete.

Answer 1

Ho creato alcune specifiche che eseguono alcuni frammenti di codice e di controllo dei risultati dell'interprete.

Si può avere uno sguardo al Frammenti tratto. L'idea è quella di memorizzare in qualche org.specs.util.Property [Snippet] il codice da eseguire:

val it: Property[Snippet] = Property(Snippet(""))
"import scala.collection.List" prelude it // will be prepended to any code in the it snippet
"val list: List[Int] = List(1, 2, 3)" snip it // snip some code (keeping the prelude)
"list.add("Chicka-Chicka-Boom-Boom")" add it  // add some code to the previously snipped code. A new snip would remove the previous code (except the prelude)

 execute(it) must include("error: value add is not a member of List[Int]") // check the interpreter output

Il principale svantaggio che ho trovato con questo approccio è stata la lentezza del interprete. Non so ancora quanto questo potrebbe essere accelerato.

Eric.