org.scalatest

# Informer

#### trait Informer extends (String) ⇒ Unit

Trait to which custom information about a running suite of tests can be reported.

An `Informer` is essentially used to wrap a `Reporter` and provide easy ways to send custom information to that `Reporter` via an `InfoProvided` event. `Informer` contains an `apply` method that takes an object. The `Informer` will invoke `toString` on the passed object and forward the resulting string to the `Reporter` as the `message` parameter of an `InfoProvided` event.

Here's an example of using an `Informer` in a `Suite` subclass:

    import org.scalatest._

    class MySuite extends Suite {
      def testAddition(info: Informer) {
        assert(1 + 1 === 2)
        info("Addition seems to work")
      }
    }

If you run this `Suite` from the interpreter, you will see the message included in the printed report:

    scala> (new MySuite).execute()
    Test Starting - MySuite.testAddition(Reporter)
    Info Provided - MySuite.testAddition(Reporter): Addition seems to work
    Test Succeeded - MySuite.testAddition(Reporter)

Traits `FunSuite`, `Spec`, `FlatSpec`, `WordSpec`, `FeatureSpec`, and their sister traits in `org.scalatest.fixture` package declare an implicit `info` method that returns an `Informer`. This implicit `info` is used, for example, to enable the syntax offered by the `GivenWhenThen` trait, which contains methods that take an implicit `Informer`. Here's an example of a `FeatureSpec` that mixes in `GivenWhenThen`:

    import org.scalatest.FeatureSpec
    import org.scalatest.GivenWhenThen

    class ArithmeticSpec extends FeatureSpec with GivenWhenThen {

      feature("Integer arithmetic") {

        scenario("addition") {

          given("two integers")
          val x = 2
          val y = 3

          when("they are added")
          val sum = x + y

          then("the result is the sum of the two numbers")
          assert(sum === 5)
        }

        scenario("subtraction") {

          given("two integers")
          val x = 7
          val y = 2

          when("one is subtracted from the other")
          val diff = x - y

          then("the result is the difference of the two numbers")
          assert(diff === 5)
        }
      }
    }

Were you to run this `FeatureSpec` in the interpreter, you would see the following messages included in the printed report:

    scala> (new ArithmeticFeatureSpec).run()
    Feature: Integer arithmetic
      Scenario: addition
        Given two integers
        When they are added
        Then the result is the sum of the two numbers
      Scenario: subtraction
        Given two integers
        When one is subtracted from the other
        Then the result is the difference of the two numbers

Linear Supertypes
(String) ⇒ Unit, AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. Informer
2. Function1
3. AnyRef
4. Any

Visibility

1. Public
2. All

### Abstract Value Members

1. #### def apply (message: String): Unit

   Provide information to the `Reporter` as the .

   Provide information to the `Reporter` as the .

   message

     an object whose `toString` result will be forwarded to the wrapped `Reporter` via an `InfoProvided` event.

   Attributes
     abstract
   Definition Classes
     Informer → Function1

### Concrete Value Members

1. #### def != (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

2. #### def != (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

3. #### def ## (): Int

   Attributes
     final
   Definition Classes
     AnyRef → Any

4. #### def == (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

5. #### def == (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

6. #### def andThen [A] (g: (Unit) ⇒ A): (String) ⇒ A

   Definition Classes
     Function1

7. #### def asInstanceOf [T0] : T0

   Attributes
     final
   Definition Classes
     Any

8. #### def clone (): AnyRef

   Attributes
     protected[lang]
   Definition Classes
     AnyRef
   Annotations
     @throws()

9. #### def compose [A] (g: (A) ⇒ String): (A) ⇒ Unit

   Definition Classes
     Function1

10. #### def eq (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

11. #### def equals (arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

12. #### def finalize (): Unit

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

13. #### def getClass (): java.lang.Class[_]

    Attributes
      final
    Definition Classes
      AnyRef

14. #### def hashCode (): Int

    Definition Classes
      AnyRef → Any

15. #### def isInstanceOf [T0] : Boolean

    Attributes
      final
    Definition Classes
      Any

16. #### def ne (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

17. #### def notify (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

18. #### def notifyAll (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

19. #### def synchronized [T0] (arg0: ⇒ T0): T0

    Attributes
      final
    Definition Classes
      AnyRef

20. #### def toString (): String

    Definition Classes
      Function1 → AnyRef → Any

21. #### def wait (): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

22. #### def wait (arg0: Long, arg1: Int): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

23. #### def wait (arg0: Long): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

### Inherited from (String) ⇒ Unit

### Inherited from AnyRef

### Inherited from Any