Come eseguire un'istanza di controllo con Scala (Test)

Question

Sto cercando di incorporare ScalaTest nel mio progetto Java, sostituendo tutti i test JUnit di ScalaTests. A un certo punto, voglio controllare se l'iniettore di Guice inietta il tipo corretto. In Java, ho un test come questo:

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); 
    } 
} 

Ma ho un problema a fare lo stesso 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) 
     } 
    } 
} 

Esso denunce che il valore instanceof non è membro di porte/finestre/Tetto. Non posso usare instanceof in questo modo in Scala?

Answer 1

Scala non è Java. Scala non ha l'operatore instanceof invece ha un metodo parametrico chiamato isInstanceOf[Type].

Answer 2

Se si desidera essere meno JUnit-esque e se si desidera utilizzare gli abbinamenti di ScalaTest, è possibile scrivere il proprio correttore proprietà che corrisponde per tipo (cancellazione tipo barra).

Ho trovato questo thread per essere molto utile: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

Si può quindi scrivere affermazioni come:

house.door should be (anInstanceOf[WoodenDoor]) 

invece di

assert(house.door instanceof WoodenDoor) 

Answer 3

Le risposte attuali circa isInstanceOf [Tipo] e i consigli di junit sono buoni ma voglio aggiungere una cosa (per le persone che hanno ottenuto questa pagina in una capacità non legata alla junit). In molti casi la corrispondenza del modello scala si adatta alle tue esigenze. Lo raccomanderei in quei casi perché ti dà la typecasting gratuitamente e lascia meno spazio per errori.

Esempio:

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

Answer 4

Consolidare riferimento discussione ScalaTest di Guillaume (e un'altra discussione legata al da James Moore) in due metodi, aggiornato per ScalaTest 2.xe Scala 2.10 (per usare ClassTag piuttosto che manifesto):

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 ScalaTest 2.2.x (forse anche prima) si può usare: anInstance mustBe an[SomeClass]

Answer 6

io uso 2.11.8 a che fare con l'affermazione Coll riflessioni. La sintassi più recente è la seguente:

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