How to do an instanceof check with Scala(Test)

Question

I'm trying to incorporate ScalaTest into my Java project; replacing all JUnit tests with ScalaTests. At one point, I want to check if Guice's Injector injects the correct type. In Java, I have a test like this:

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

But I have a problem doing the same with 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 complains that the value instanceof is not a member of Door/Window/Roof. Can't I use instanceof that way in Scala?

martin-g · Accepted Answer · 2018-07-25T20:51:45.193

128

With Scalatest 2.2.x (maybe even earlier) you can use:

anInstance mustBe a[SomeClass]

edited Jul 25 '18 at 20:51

answered Aug 08 '14 at 22:07

martin-g

17,243
2
23
35

4

This is the recommended approach on recent versions of ScalaTests – maasg Jun 07 '16 at 16:35
6

also available `a[Type]` so you can be grammatically correct ;) – Samuel Jun 30 '16 at 22:39
I was looking for that! :) – Atais Feb 13 '17 at 11:57
26

`tiger shouldBe a [Tiger]` is the current syntax http://www.scalatest.org/at_a_glance/FlatSpec – jhegedus May 16 '17 at 04:06
3

@jhegedus `mustBe` is also correct, if you use http://doc.scalatest.org/3.0.1/#org.scalatest.MustMatchers which you want for FreeSpec. – Tobi Jul 13 '17 at 08:35

agilesteel · Answer 2 · 2018-08-26T10:25:06.603

124

Scala is not Java. Scala just does not have the operator instanceof instead it has a parametric method called isInstanceOf[Type].

You might also enjoy watching a ScalaTest Crash Course.

edited Aug 26 '18 at 10:25

answered Dec 19 '11 at 13:27

agilesteel

16,775
6
44
55

7

well, that doesn't really answer the question. ScalaTest has built-in support for type check. See the answer from @martin-g – maasg Jun 07 '16 at 16:38
How to do it if "Type" it's a trait? – Lobo Dec 29 '17 at 08:35
Not sure if I understand correctly, but it should be the same: `isInstanceOf[TraitName]`. – agilesteel Dec 29 '17 at 12:13

score 30 · Answer 3 · edited Dec 03 '12 at 20:24

30

If you want to be less JUnit-esque and if you want to use ScalaTest's matchers, you can write your own property matcher that matches for type (bar type erasure).

I found this thread to be quite useful: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

You can then write assertions like:

house.door should be (anInstanceOf[WoodenDoor])

instead of

assert(house.door instanceof WoodenDoor)

edited Dec 03 '12 at 20:24

EdChum

376,765
198
813
562

answered Dec 19 '11 at 15:09

Guillaume Belrose

2,478
4
23
24

+1 That looks very nice, and even understandable for non-programming people (assuming they know what an instance is :-)). – helpermethod Dec 19 '11 at 15:15
If syntax sugar is what you are after, with some refactoring you might be able to write house.door should be (madeOf[Wood]) or house.door should be (madeOf[Bamboo]). – Guillaume Belrose Dec 19 '11 at 15:34
1

Also see https://groups.google.com/d/topic/scalatest-users/HeOKgs5PC2o/discussion – James Moore Dec 30 '12 at 18:30

score 18 · Answer 4 · answered May 01 '14 at 22:24

The current answers about isInstanceOf[Type] and junit advice are good but I want to add one thing (for people who got to this page in a non-junit-related capacity). In many cases scala pattern matching will suit your needs. I would recommend it in those cases because it gives you the typecasting for free and leaves less room for error.

Example:

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

The recommended way to test a pattern match in ScalaTest is to use `inside(foo)` instead of `foo match). See http://www.scalatest.org/user_guide/using_matchers#matchingAPattern — Rich Dougherty, Aug 24 '17 at 19:37

Raman · Answer 5 · 2014-05-15T16:44:19.103

Consolidating Guillaume's ScalaTest discussion reference (and another discussion linked to by James Moore) into two methods, updated for ScalaTest 2.x and Scala 2.10 (to use ClassTag rather than manifest):

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

aristotll · Answer 6 · 2017-08-24T23:07:44.527

2

I use 2.11.8 to do the assertion with collections. The newer syntax is as follows:

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

edited Aug 24 '17 at 23:07

answered Aug 21 '17 at 15:15

aristotll

8,694
6
33
53

3

Due to erasure you cannot check the `Map`'s type parameters. What you wrote is the same as writing `scores shouldBe a[Map[_, _]]`. This is mentioned here: http://www.scalatest.org/user_guide/using_matchers#checkingAnObjectsClass – Rich Dougherty Aug 24 '17 at 19:34

How to do an instanceof check with Scala(Test)

6 Answers6

Linked

Related