Cómo hacer una instancia de comprobación con Scala (Prueba)

Question

Estoy tratando de incorporar ScalaTest a mi proyecto Java, reemplazando todas las pruebas JUnit por ScalaTests. En un punto, quiero verificar si el inyector de Guice inyecta el tipo correcto. En Java, tengo una prueba como esta:

public class InjectorBehaviour { 
    @Test 
    public void shouldInjectCorrectTypes() { 
     Injector injector = Guice.createInjector(new ModuleImpl()); 
     House house = injector.getInstance(House.class); 

     assertTrue(house.door() instanceof WoodenDoor); 
     assertTrue(house.window() instanceof BambooWindow); 
     assertTrue(house.roof() instanceof SlateRoof); 
    } 
} 

pero tengo un problema en hacer lo mismo con ScalaTest:

class InjectorSpec extends Spec { 
    describe("An injector") { 
     it("should inject the correct types") { 
      val injector = Guice.createInjector(new ModuleImpl) 
      val house = injector.getInstance(classOf[House]) 

      assert(house.door instanceof WoodenDoor) 
      assert(house.window instanceof BambooWindow) 
      assert(house.roof instanceof SlateRoof) 
     } 
    } 
} 

It quejas de que el valor instanceof no es miembro de la puerta/ventana/Techo. ¿No puedo usar instanceof de esa manera en Scala?

Answer 1

Scala no es Java. Scala simplemente no tiene el operador instanceof sino que tiene un método paramétrico llamado isInstanceOf[Type].

Answer 2

Si quiere ser menos parecido a JUnit y si quiere usar los equivalentes de ScalaTest, puede escribir su propio marcador de propiedad que coincida con el tipo (borrado de tipo de barra).

He encontrado este hilo para ser muy útil: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

entonces usted puede escribir afirmaciones como:

house.door should be (anInstanceOf[WoodenDoor]) 

en lugar de

assert(house.door instanceof WoodenDoor) 

Answer 3

las respuestas actuales sobre isInstanceOf [Type] y Los consejos junit son buenos, pero quiero agregar una cosa (para las personas que llegaron a esta página en una capacidad no relacionada con junit). En muchos casos, la coincidencia de patrones scala se ajustará a sus necesidades. Lo recomendaría en esos casos porque te da el encasillado de forma gratuita y deja menos espacio para el error.

Ejemplo:

OuterType foo = blah 
foo match { 
    case subFoo : SubType => { 
    subFoo.thingSubTypeDoes // no need to cast, use match variable 
    } 
    case subFoo => { 
    // fallthrough code 
    } 
} 

Answer 4

La consolidación de referencia discusión ScalaTest de Guillaume (y otra discusión vinculada a por James Moore) en dos métodos, actualizado para 2.x ScalaTest y Scala 2,10 (para usar ClassTag en lugar de manifiesto):

import org.scalatest.matchers._ 
import scala.reflect._ 

def ofType[T:ClassTag] = BeMatcher { obj: Any => 
    val cls = classTag[T].runtimeClass 
    MatchResult(
    obj.getClass == cls, 
    obj.toString + " was not an instance of " + cls.toString, 
    obj.toString + " was an instance of " + cls.toString 
) 
} 

def anInstanceOf[T:ClassTag] = BeMatcher { obj: Any => 
    val cls = classTag[T].runtimeClass 
    MatchResult(
    cls.isAssignableFrom(obj.getClass), 
    obj.getClass.toString + " was not assignable from " + cls.toString, 
    obj.getClass.toString + " was assignable from " + cls.toString 
) 
} 

Answer 5

con 2.2.x Scalatest (tal vez incluso antes) se puede utilizar: anInstance mustBe an[SomeClass]

Answer 6

utilizo 2.11.8 que ver con la afirmación coll ecciones. La sintaxis más nueva es la siguiente:

val scores: Map[String, Int] = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8) 
scores shouldBe a[Map[_, _]]